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         const 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                                                                                          int,
 143                                                                                          const VkRectLayerKHR *
 144                                                                                          );
 145         void                                    (*deinit)               (VkDevice,
 146                                                                                          vk_swapchain_t *);
 147
 148         uint32_t                                 buffer_count;
 149         vk_buffer_t                             *buffers;
 150
 151         vk_swapchain_t                  *oldSwapchain;
 152         vk_bool_t                               is_retired;
 153
 154         void *backend_data;
 155 };
 156
 157 struct vk_tbm_queue_surface {
 158         VkIcdSurfaceBase base;
 159         tbm_bufmgr bufmgr;
 160         tbm_surface_queue_h tbm_queue;
 161 };
 162
 163 VkBool32
 164 vk_physical_device_init_display(vk_physical_device_t *pdev);
 165
 166 void
 167 vk_physical_device_fini_display(vk_physical_device_t *pdev);
 168
 169 const VkAllocationCallbacks *
 170 vk_get_allocator(void *parent, const VkAllocationCallbacks *allocator);
 171
 172 void *
 173 vk_alloc(const VkAllocationCallbacks *allocator, size_t size, VkSystemAllocationScope scope);
 174
 175 void *
 176 vk_realloc(const VkAllocationCallbacks *allocator, void *mem, size_t size,
 177                    VkSystemAllocationScope scope);
 178
 179 void
 180 vk_free(const VkAllocationCallbacks *allocator, void *mem);
 181
 182 #pragma GCC diagnostic push
 183 #pragma GCC diagnostic ignored "-Wswitch"
 184 static inline tpl_display_t *
 185 vk_get_tpl_display(VkIcdSurfaceBase             *sfc)
 186 {
 187         tpl_backend_type_t type = TPL_BACKEND_UNKNOWN;
 188         tpl_handle_t native_dpy = NULL;
 189
 190         switch (sfc->platform) {
 191                 case VK_ICD_WSI_PLATFORM_WAYLAND:
 192                         type = TPL_BACKEND_WAYLAND_VULKAN_WSI_THREAD;
 193                         native_dpy = ((VkIcdSurfaceWayland *)(uintptr_t)sfc)->display;
 194                         break;
 195                 case VK_ICD_WSI_PLATFORM_TBM_QUEUE:
 196                         type = TPL_BACKEND_TBM;
 197                         native_dpy = ((vk_tbm_queue_surface_t *)(uintptr_t)sfc)->bufmgr;
 198                         break;
 199                 default:
 200                         return NULL;
 201         }
 202
 203         tpl_display_t *display = tpl_display_get_with_backend_type(type, native_dpy);
 204
 205         if (display == NULL)
 206                 display = tpl_display_create(type, native_dpy);
 207         else
 208                 tpl_object_reference((tpl_object_t *)display);
 209
 210         return display;
 211 };
 212
 213 static inline tpl_handle_t
 214 vk_get_tpl_native_window(VkIcdSurfaceBase               *sfc)
 215 {
 216         switch (sfc->platform) {
 217                 case VK_ICD_WSI_PLATFORM_WAYLAND:
 218                         return ((VkIcdSurfaceWayland *)(uintptr_t)sfc)->surface;
 219                 case VK_ICD_WSI_PLATFORM_TBM_QUEUE:
 220                         return ((vk_tbm_queue_surface_t *)(uintptr_t)sfc)->tbm_queue;
 221                 default:
 222                         return NULL;
 223         }
 224         return NULL;
 225 }
 226 #pragma GCC diagnostic pop
 227
 228 VkResult
 229 swapchain_tpl_init(VkDevice device, const VkSwapchainCreateInfoKHR *info,
 230                                    vk_swapchain_t *chain, tbm_format format);
 231
 232 VkResult
 233 swapchain_tdm_init(VkDevice device, const VkSwapchainCreateInfoKHR *info,
 234                                    vk_swapchain_t *chain, tbm_format format);
 235
 236 /* Entry point proto types. */
 237 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
 238 vk_icdGetInstanceProcAddr(VkInstance instance, const char *name);
 239
 240 VKAPI_ATTR VkResult VKAPI_CALL
 241 vk_GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice pdev, uint32_t queue_family_index,
 242                                                                           VkSurfaceKHR surface, VkBool32 *supported);
 243
 244 VKAPI_ATTR VkResult VKAPI_CALL
 245 vk_GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice pdev, VkSurfaceKHR surface,
 246                                                                                    VkSurfaceCapabilitiesKHR *caps);
 247
 248 VKAPI_ATTR VkResult VKAPI_CALL
 249 vk_GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, VkSurfaceKHR surface,
 250                                                                           uint32_t *format_count, VkSurfaceFormatKHR *formats);
 251
 252 VKAPI_ATTR VkResult VKAPI_CALL
 253 vk_GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev, VkSurfaceKHR surface,
 254                                                                                    uint32_t *mode_count, VkPresentModeKHR *modes);
 255
 256 VKAPI_ATTR VkResult VKAPI_CALL
 257 vk_CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *info,
 258                                           const VkAllocationCallbacks *allocator, VkSwapchainKHR *swapchain);
 259
 260 VKAPI_ATTR void VKAPI_CALL
 261 vk_DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
 262                                            const VkAllocationCallbacks *allocator);
 263
 264 VKAPI_ATTR VkResult VKAPI_CALL
 265 vk_GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *image_count,
 266                                                  VkImage *images);
 267
 268 VKAPI_ATTR VkResult VKAPI_CALL
 269 vk_AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout,
 270                                            VkSemaphore semaphore, VkFence fence, uint32_t *image_index);
 271
 272 VKAPI_ATTR VkResult VKAPI_CALL
 273 vk_QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *info);
 274
 275 VKAPI_ATTR VkResult VKAPI_CALL
 276 vk_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice pdev, uint32_t *prop_count,
 277                                                                                  VkDisplayPropertiesKHR *props);
 278
 279 VKAPI_ATTR VkResult VKAPI_CALL
 280 vk_GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice pdev, uint32_t *prop_count,
 281                                                                                           VkDisplayPlanePropertiesKHR *props);
 282
 283 VKAPI_ATTR VkResult VKAPI_CALL
 284 vk_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice pdev, uint32_t plane_index,
 285                                                                            uint32_t *display_count, VkDisplayKHR *displays);
 286
 287 VKAPI_ATTR VkResult VKAPI_CALL
 288 vk_GetDisplayModePropertiesKHR(VkPhysicalDevice pdev, VkDisplayKHR display, uint32_t *prop_count,
 289                                                            VkDisplayModePropertiesKHR *props);
 290
 291 VKAPI_ATTR VkResult VKAPI_CALL
 292 vk_CreateDisplayModeKHR(VkPhysicalDevice pdev, VkDisplayKHR display,
 293                                                 const VkDisplayModeCreateInfoKHR *info,
 294                                                 const VkAllocationCallbacks *allocator, VkDisplayModeKHR *mode);
 295
 296 VKAPI_ATTR VkResult VKAPI_CALL
 297 vk_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice pdev, VkDisplayModeKHR mode,
 298                                                                   uint32_t plane_index, VkDisplayPlaneCapabilitiesKHR *caps);
 299
 300 VKAPI_ATTR VkResult VKAPI_CALL
 301 vk_CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchain_count,
 302                                                          const VkSwapchainCreateInfoKHR *infos,
 303                                                          const VkAllocationCallbacks *allocator, VkSwapchainKHR *swapchains);
 304
 305 VKAPI_ATTR VkBool32 VKAPI_CALL
 306 vk_GetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice pdev,
 307                                                                                                   uint32_t queue_family_index,
 308                                                                                                   struct wl_display *display);
 309
 310 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
 311 vk_GetInstanceProcAddr(VkInstance instance, const char *name);
 312
 313 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
 314 vk_GetDeviceProcAddr(VkDevice device, const char *name);
 315
 316 VKAPI_ATTR VkResult VKAPI_CALL
 317 vk_EnumerateInstanceExtensionProperties(const char *layer_name, uint32_t *count,
 318                                                                                 VkExtensionProperties *extensions);
 319
 320 VKAPI_ATTR VkResult VKAPI_CALL
 321 vk_EnumerateDeviceExtensionProperties(VkPhysicalDevice pdev, const char *layer_name,
 322                                                                           uint32_t *count, VkExtensionProperties *extensions);
 323
 324 VKAPI_ATTR VkResult VKAPI_CALL
 325 vk_CreateTBMQueueSurfaceKHR(VkInstance instance,
 326                                                         const tbm_bufmgr bufmgr, const tbm_surface_queue_h queue,
 327                                                         const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *surface);
 328 #endif /* WSI_H */