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         else
 202                 tpl_object_reference(display);
 203
 204         return display;
 205 };
 206
 207 static inline tpl_handle_t
 208 vk_get_tpl_native_window(VkIcdSurfaceBase               *sfc)
 209 {
 210         switch (sfc->platform) {
 211                 case VK_ICD_WSI_PLATFORM_WAYLAND:
 212                         return ((VkIcdSurfaceWayland *)(uintptr_t)sfc)->surface;
 213                 case VK_ICD_WSI_PLATFORM_TBM_QUEUE:
 214                         return ((vk_tbm_queue_surface_t *)(uintptr_t)sfc)->tbm_queue;
 215                 default:
 216                         return NULL;
 217         }
 218         return NULL;
 219 }
 220 #pragma GCC diagnostic pop
 221
 222 VkResult
 223 swapchain_tpl_init(VkDevice device, const VkSwapchainCreateInfoKHR *info,
 224                                    vk_swapchain_t *chain, tbm_format format);
 225
 226 VkResult
 227 swapchain_tdm_init(VkDevice device, const VkSwapchainCreateInfoKHR *info,
 228                                    vk_swapchain_t *chain, tbm_format format);
 229
 230 /* Entry point proto types. */
 231 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
 232 vk_icdGetInstanceProcAddr(VkInstance instance, const char *name);
 233
 234 VKAPI_ATTR VkResult VKAPI_CALL
 235 vk_GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice pdev, uint32_t queue_family_index,
 236                                                                           VkSurfaceKHR surface, VkBool32 *supported);
 237
 238 VKAPI_ATTR VkResult VKAPI_CALL
 239 vk_GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice pdev, VkSurfaceKHR surface,
 240                                                                                    VkSurfaceCapabilitiesKHR *caps);
 241
 242 VKAPI_ATTR VkResult VKAPI_CALL
 243 vk_GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, VkSurfaceKHR surface,
 244                                                                           uint32_t *format_count, VkSurfaceFormatKHR *formats);
 245
 246 VKAPI_ATTR VkResult VKAPI_CALL
 247 vk_GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev, VkSurfaceKHR surface,
 248                                                                                    uint32_t *mode_count, VkPresentModeKHR *modes);
 249
 250 VKAPI_ATTR VkResult VKAPI_CALL
 251 vk_CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *info,
 252                                           const VkAllocationCallbacks *allocator, VkSwapchainKHR *swapchain);
 253
 254 VKAPI_ATTR void VKAPI_CALL
 255 vk_DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
 256                                            const VkAllocationCallbacks *allocator);
 257
 258 VKAPI_ATTR VkResult VKAPI_CALL
 259 vk_GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *image_count,
 260                                                  VkImage *images);
 261
 262 VKAPI_ATTR VkResult VKAPI_CALL
 263 vk_AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout,
 264                                            VkSemaphore semaphore, VkFence fence, uint32_t *image_index);
 265
 266 VKAPI_ATTR VkResult VKAPI_CALL
 267 vk_QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *info);
 268
 269 VKAPI_ATTR VkResult VKAPI_CALL
 270 vk_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice pdev, uint32_t *prop_count,
 271                                                                                  VkDisplayPropertiesKHR *props);
 272
 273 VKAPI_ATTR VkResult VKAPI_CALL
 274 vk_GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice pdev, uint32_t *prop_count,
 275                                                                                           VkDisplayPlanePropertiesKHR *props);
 276
 277 VKAPI_ATTR VkResult VKAPI_CALL
 278 vk_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice pdev, uint32_t plane_index,
 279                                                                            uint32_t *display_count, VkDisplayKHR *displays);
 280
 281 VKAPI_ATTR VkResult VKAPI_CALL
 282 vk_GetDisplayModePropertiesKHR(VkPhysicalDevice pdev, VkDisplayKHR display, uint32_t *prop_count,
 283                                                            VkDisplayModePropertiesKHR *props);
 284
 285 VKAPI_ATTR VkResult VKAPI_CALL
 286 vk_CreateDisplayModeKHR(VkPhysicalDevice pdev, VkDisplayKHR display,
 287                                                 const VkDisplayModeCreateInfoKHR *info,
 288                                                 const VkAllocationCallbacks *allocator, VkDisplayModeKHR *mode);
 289
 290 VKAPI_ATTR VkResult VKAPI_CALL
 291 vk_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice pdev, VkDisplayModeKHR mode,
 292                                                                   uint32_t plane_index, VkDisplayPlaneCapabilitiesKHR *caps);
 293
 294 VKAPI_ATTR VkResult VKAPI_CALL
 295 vk_CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchain_count,
 296                                                          const VkSwapchainCreateInfoKHR *infos,
 297                                                          const VkAllocationCallbacks *allocator, VkSwapchainKHR *swapchains);
 298
 299 VKAPI_ATTR VkBool32 VKAPI_CALL
 300 vk_GetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice pdev,
 301                                                                                                   uint32_t queue_family_index,
 302                                                                                                   struct wl_display *display);
 303
 304 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
 305 vk_GetInstanceProcAddr(VkInstance instance, const char *name);
 306
 307 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
 308 vk_GetDeviceProcAddr(VkDevice device, const char *name);
 309
 310 VKAPI_ATTR VkResult VKAPI_CALL
 311 vk_EnumerateInstanceExtensionProperties(const char *layer_name, uint32_t *count,
 312                                                                                 VkExtensionProperties *extensions);
 313
 314 VKAPI_ATTR VkResult VKAPI_CALL
 315 vk_EnumerateDeviceExtensionProperties(VkPhysicalDevice pdev, const char *layer_name,
 316                                                                           uint32_t *count, VkExtensionProperties *extensions);
 317
 318 VKAPI_ATTR VkResult VKAPI_CALL
 319 vk_CreateTBMQueueSurfaceKHR(VkInstance instance,
 320                                                         const tbm_bufmgr bufmgr, const tbm_surface_queue_h queue,
 321                                                         const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *surface);
 322 #endif /* WSI_H */