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 typedef struct vk_tbm_queue_surface     vk_tbm_queue_surface_t;
  52
  53 struct vk_icd {
  54         void    *lib;
  55
  56         PFN_vkGetInstanceProcAddr                                       get_proc_addr;
  57         PFN_vkEnumerateDeviceExtensionProperties        enum_dev_exts;
  58
  59         uint32_t                                 instance_extension_count;
  60         VkExtensionProperties   *instance_extensions;
  61
  62         /* WSI-ICD interface. */
  63         PFN_vkCreateImageFromNativeBufferTIZEN  create_presentable_image;
  64         PFN_vkQueueSignalReleaseImageTIZEN              queue_signal_release_image;
  65         PFN_vkAcquireImageTIZEN                                 acquire_image;
  66 };
  67
  68 vk_icd_t *
  69 vk_get_icd(void);
  70
  71 vk_physical_device_t *
  72 vk_get_physical_device(VkPhysicalDevice pdev);
  73
  74 struct vk_display {
  75         vk_physical_device_t    *pdev;
  76
  77         tdm_output                              *tdm_output;
  78
  79         VkDisplayPropertiesKHR   prop;
  80
  81         uint32_t                                 built_in_mode_count;
  82         vk_display_mode_t               *built_in_modes;
  83
  84         uint32_t                                 custom_mode_count;
  85         vk_display_mode_t               *custom_modes;
  86 };
  87
  88 struct vk_display_plane {
  89         vk_physical_device_t            *pdev;
  90
  91         tdm_layer                                       *tdm_layer;
  92
  93         VkDisplayPlanePropertiesKHR      prop;
  94
  95         uint32_t                                         supported_display_count;
  96         vk_display_t                            *supported_displays[VK_MAX_DISPLAY_COUNT];
  97
  98         vk_display_t                            *current_display;
  99         uint32_t                                         current_stack_index;
 100 };
 101
 102 struct vk_display_mode {
 103         vk_display_t                            *display;
 104         VkDisplayModePropertiesKHR       prop;
 105         const tdm_output_mode           *tdm_mode;
 106 };
 107
 108 struct vk_physical_device {
 109         VkPhysicalDevice         pdev;
 110
 111         tdm_display                     *tdm_display;
 112
 113         uint32_t                         display_count;
 114         vk_display_t             displays[VK_MAX_DISPLAY_COUNT];
 115
 116         uint32_t                         plane_count;
 117         vk_display_plane_t       planes[VK_MAX_PLANE_COUNT];
 118 };
 119
 120 struct vk_buffer {
 121         tbm_surface_h   tbm;
 122         VkImage                 image;
 123 };
 124
 125 struct vk_swapchain {
 126         VkAllocationCallbacks    allocator;
 127         VkSurfaceKHR                     surface;
 128
 129         VkResult                                (*get_buffers)  (VkDevice,
 130                                                                                          vk_swapchain_t *,
 131                                                                                          tbm_surface_h **,
 132                                                                                          uint32_t *);   /* buffer count */
 133         VkResult                                (*acquire_image)(VkDevice,
 134                                                                                          vk_swapchain_t *,
 135                                                                                          uint64_t,              /* timeout */
 136                                                                                          tbm_surface_h *,
 137                                                                                          int *);                /* sync fd */
 138         VkResult                                (*present_image)(VkQueue,
 139                                                                                          vk_swapchain_t *,
 140                                                                                          tbm_surface_h,
 141                                                                                          int);                  /* sync fd */
 142         void                                    (*deinit)               (VkDevice,
 143                                                                                          vk_swapchain_t *);
 144
 145         uint32_t                                 buffer_count;
 146         vk_buffer_t                             *buffers;
 147
 148         void *backend_data;
 149 };
 150
 151 struct vk_tbm_queue_surface {
 152         VkIcdSurfaceBase base;
 153         tbm_bufmgr bufmgr;
 154         tbm_surface_queue_h tbm_queue;
 155 };
 156
 157 VkBool32
 158 vk_physical_device_init_display(vk_physical_device_t *pdev);
 159
 160 void
 161 vk_physical_device_fini_display(vk_physical_device_t *pdev);
 162
 163 const VkAllocationCallbacks *
 164 vk_get_allocator(void *parent, const VkAllocationCallbacks *allocator);
 165
 166 void *
 167 vk_alloc(const VkAllocationCallbacks *allocator, size_t size, VkSystemAllocationScope scope);
 168
 169 void *
 170 vk_realloc(const VkAllocationCallbacks *allocator, void *mem, size_t size,
 171                    VkSystemAllocationScope scope);
 172
 173 void
 174 vk_free(const VkAllocationCallbacks *allocator, void *mem);
 175
 176 #pragma GCC diagnostic push
 177 #pragma GCC diagnostic ignored "-Wswitch"
 178 static inline tpl_display_t *
 179 vk_get_tpl_display(VkIcdSurfaceBase             *sfc)
 180 {
 181         tpl_backend_type_t type = TPL_BACKEND_UNKNOWN;
 182         tpl_handle_t native_dpy = NULL;
 183
 184         switch (sfc->platform) {
 185                 case VK_ICD_WSI_PLATFORM_WAYLAND:
 186                         type = TPL_BACKEND_WAYLAND_VULKAN_WSI_THREAD;
 187                         native_dpy = ((VkIcdSurfaceWayland *)(uintptr_t)sfc)->display;
 188                         break;
 189                 case VK_ICD_WSI_PLATFORM_TBM_QUEUE:
 190                         type = TPL_BACKEND_TBM;
 191                         native_dpy = ((vk_tbm_queue_surface_t *)(uintptr_t)sfc)->bufmgr;
 192                         break;
 193                 default:
 194                         return NULL;
 195         }
 196
 197         tpl_display_t *display = tpl_display_get(native_dpy);
 198
 199         if (display == NULL)
 200                 display = tpl_display_create(type, native_dpy);
 201
 202         return display;
 203 };
 204
 205 static inline tpl_handle_t
 206 vk_get_tpl_native_window(VkIcdSurfaceBase               *sfc)
 207 {
 208         switch (sfc->platform) {
 209                 case VK_ICD_WSI_PLATFORM_WAYLAND:
 210                         return ((VkIcdSurfaceWayland *)(uintptr_t)sfc)->surface;
 211                 case VK_ICD_WSI_PLATFORM_TBM_QUEUE:
 212                         return ((vk_tbm_queue_surface_t *)(uintptr_t)sfc)->tbm_queue;
 213                 default:
 214                         return NULL;
 215         }
 216         return NULL;
 217 }
 218 #pragma GCC diagnostic pop
 219
 220 VkResult
 221 swapchain_tpl_init(VkDevice device, const VkSwapchainCreateInfoKHR *info,
 222                                    vk_swapchain_t *chain, tbm_format format);
 223
 224 VkResult
 225 swapchain_tdm_init(VkDevice device, const VkSwapchainCreateInfoKHR *info,
 226                                    vk_swapchain_t *chain, tbm_format format);
 227
 228 /* Entry point proto types. */
 229 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
 230 vk_icdGetInstanceProcAddr(VkInstance instance, const char *name);
 231
 232 VKAPI_ATTR VkResult VKAPI_CALL
 233 vk_GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice pdev, uint32_t queue_family_index,
 234                                                                           VkSurfaceKHR surface, VkBool32 *supported);
 235
 236 VKAPI_ATTR VkResult VKAPI_CALL
 237 vk_GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice pdev, VkSurfaceKHR surface,
 238                                                                                    VkSurfaceCapabilitiesKHR *caps);
 239
 240 VKAPI_ATTR VkResult VKAPI_CALL
 241 vk_GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, VkSurfaceKHR surface,
 242                                                                           uint32_t *format_count, VkSurfaceFormatKHR *formats);
 243
 244 VKAPI_ATTR VkResult VKAPI_CALL
 245 vk_GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev, VkSurfaceKHR surface,
 246                                                                                    uint32_t *mode_count, VkPresentModeKHR *modes);
 247
 248 VKAPI_ATTR VkResult VKAPI_CALL
 249 vk_CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *info,
 250                                           const VkAllocationCallbacks *allocator, VkSwapchainKHR *swapchain);
 251
 252 VKAPI_ATTR void VKAPI_CALL
 253 vk_DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
 254                                            const VkAllocationCallbacks *allocator);
 255
 256 VKAPI_ATTR VkResult VKAPI_CALL
 257 vk_GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *image_count,
 258                                                  VkImage *images);
 259
 260 VKAPI_ATTR VkResult VKAPI_CALL
 261 vk_AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout,
 262                                            VkSemaphore semaphore, VkFence fence, uint32_t *image_index);
 263
 264 VKAPI_ATTR VkResult VKAPI_CALL
 265 vk_QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *info);
 266
 267 VKAPI_ATTR VkResult VKAPI_CALL
 268 vk_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice pdev, uint32_t *prop_count,
 269                                                                                  VkDisplayPropertiesKHR *props);
 270
 271 VKAPI_ATTR VkResult VKAPI_CALL
 272 vk_GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice pdev, uint32_t *prop_count,
 273                                                                                           VkDisplayPlanePropertiesKHR *props);
 274
 275 VKAPI_ATTR VkResult VKAPI_CALL
 276 vk_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice pdev, uint32_t plane_index,
 277                                                                            uint32_t *display_count, VkDisplayKHR *displays);
 278
 279 VKAPI_ATTR VkResult VKAPI_CALL
 280 vk_GetDisplayModePropertiesKHR(VkPhysicalDevice pdev, VkDisplayKHR display, uint32_t *prop_count,
 281                                                            VkDisplayModePropertiesKHR *props);
 282
 283 VKAPI_ATTR VkResult VKAPI_CALL
 284 vk_CreateDisplayModeKHR(VkPhysicalDevice pdev, VkDisplayKHR display,
 285                                                 const VkDisplayModeCreateInfoKHR *info,
 286                                                 const VkAllocationCallbacks *allocator, VkDisplayModeKHR *mode);
 287
 288 VKAPI_ATTR VkResult VKAPI_CALL
 289 vk_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice pdev, VkDisplayModeKHR mode,
 290                                                                   uint32_t plane_index, VkDisplayPlaneCapabilitiesKHR *caps);
 291
 292 VKAPI_ATTR VkResult VKAPI_CALL
 293 vk_CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchain_count,
 294                                                          const VkSwapchainCreateInfoKHR *infos,
 295                                                          const VkAllocationCallbacks *allocator, VkSwapchainKHR *swapchains);
 296
 297 VKAPI_ATTR VkBool32 VKAPI_CALL
 298 vk_GetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice pdev,
 299                                                                                                   uint32_t queue_family_index,
 300                                                                                                   struct wl_display *display);
 301
 302 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
 303 vk_GetInstanceProcAddr(VkInstance instance, const char *name);
 304
 305 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
 306 vk_GetDeviceProcAddr(VkDevice device, const char *name);
 307
 308 VKAPI_ATTR VkResult VKAPI_CALL
 309 vk_EnumerateInstanceExtensionProperties(const char *layer_name, uint32_t *count,
 310                                                                                 VkExtensionProperties *extensions);
 311
 312 VKAPI_ATTR VkResult VKAPI_CALL
 313 vk_EnumerateDeviceExtensionProperties(VkPhysicalDevice pdev, const char *layer_name,
 314                                                                           uint32_t *count, VkExtensionProperties *extensions);
 315
 316 VKAPI_ATTR VkResult VKAPI_CALL
 317 vk_CreateTBMQueueSurfaceKHR(VkInstance instance,
 318                                                         const tbm_bufmgr bufmgr, const tbm_surface_queue_h queue,
 319                                                         const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *surface);
 320 #endif /* WSI_H */