dlls/winemac.drv/vulkan.c

   1 /* Mac Driver Vulkan implementation
   2  *
   3  * Copyright 2017 Roderick Colenbrander
   4  * Copyright 2018 Andrew Eikum for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 /* NOTE: If making changes here, consider whether they should be reflected in
  22  * the other drivers. */
  23
  24 #include "config.h"
  25 #include "wine/port.h"
  26 #include "macdrv.h"
  27
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30
  31 #include "windef.h"
  32 #include "winbase.h"
  33
  34 #include "wine/debug.h"
  35 #include "wine/heap.h"
  36 #include "wine/library.h"
  37
  38 #define VK_NO_PROTOTYPES
  39 #define WINE_VK_HOST
  40
  41 #include "wine/vulkan.h"
  42 #include "wine/vulkan_driver.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
  45
  46 #ifdef SONAME_LIBMOLTENVK
  47
  48 typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
  49 #define VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK 1000123000
  50
  51 struct wine_vk_surface
  52 {
  53     macdrv_metal_device device;
  54     macdrv_metal_view view;
  55     VkSurfaceKHR surface; /* native surface */
  56 };
  57
  58 typedef struct VkMacOSSurfaceCreateInfoMVK
  59 {
  60     VkStructureType sType;
  61     const void *pNext;
  62     VkMacOSSurfaceCreateFlagsMVK flags;
  63     const void *pView; /* NSView */
  64 } VkMacOSSurfaceCreateInfoMVK;
  65
  66 static VkResult (*pvkCreateInstance)(const VkInstanceCreateInfo *, const VkAllocationCallbacks *, VkInstance *);
  67 static VkResult (*pvkCreateSwapchainKHR)(VkDevice, const VkSwapchainCreateInfoKHR *, const VkAllocationCallbacks *, VkSwapchainKHR *);
  68 static VkResult (*pvkCreateMacOSSurfaceMVK)(VkInstance, const VkMacOSSurfaceCreateInfoMVK*, const VkAllocationCallbacks *, VkSurfaceKHR *);
  69 static void (*pvkDestroyInstance)(VkInstance, const VkAllocationCallbacks *);
  70 static void (*pvkDestroySurfaceKHR)(VkInstance, VkSurfaceKHR, const VkAllocationCallbacks *);
  71 static void (*pvkDestroySwapchainKHR)(VkDevice, VkSwapchainKHR, const VkAllocationCallbacks *);
  72 static VkResult (*pvkEnumerateInstanceExtensionProperties)(const char *, uint32_t *, VkExtensionProperties *);
  73 static void * (*pvkGetDeviceProcAddr)(VkDevice, const char *);
  74 static void * (*pvkGetInstanceProcAddr)(VkInstance, const char *);
  75 static VkResult (*pvkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice, VkSurfaceKHR, VkSurfaceCapabilitiesKHR *);
  76 static VkResult (*pvkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice, VkSurfaceKHR, uint32_t *, VkSurfaceFormatKHR *);
  77 static VkResult (*pvkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice, VkSurfaceKHR, uint32_t *, VkPresentModeKHR *);
  78 static VkResult (*pvkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice, uint32_t, VkSurfaceKHR, VkBool32 *);
  79 static VkResult (*pvkGetSwapchainImagesKHR)(VkDevice, VkSwapchainKHR, uint32_t *, VkImage *);
  80 static VkResult (*pvkQueuePresentKHR)(VkQueue, const VkPresentInfoKHR *);
  81
  82 static void *macdrv_get_vk_device_proc_addr(const char *name);
  83 static void *macdrv_get_vk_instance_proc_addr(VkInstance instance, const char *name);
  84
  85 static inline struct wine_vk_surface *surface_from_handle(VkSurfaceKHR handle)
  86 {
  87     return (struct wine_vk_surface *)(uintptr_t)handle;
  88 }
  89
  90 static void *vulkan_handle;
  91
  92 static BOOL WINAPI wine_vk_init(INIT_ONCE *once, void *param, void **context)
  93 {
  94     if (!(vulkan_handle = wine_dlopen(SONAME_LIBMOLTENVK, RTLD_NOW, NULL, 0)))
  95     {
  96         ERR("Failed to load %s\n", SONAME_LIBMOLTENVK);
  97         return TRUE;
  98     }
  99
 100 #define LOAD_FUNCPTR(f) if ((p##f = wine_dlsym(vulkan_handle, #f, NULL, 0)) == NULL) goto fail;
 101     LOAD_FUNCPTR(vkCreateInstance)
 102     LOAD_FUNCPTR(vkCreateSwapchainKHR)
 103     LOAD_FUNCPTR(vkCreateMacOSSurfaceMVK)
 104     LOAD_FUNCPTR(vkDestroyInstance)
 105     LOAD_FUNCPTR(vkDestroySurfaceKHR)
 106     LOAD_FUNCPTR(vkDestroySwapchainKHR)
 107     LOAD_FUNCPTR(vkEnumerateInstanceExtensionProperties)
 108     LOAD_FUNCPTR(vkGetDeviceProcAddr)
 109     LOAD_FUNCPTR(vkGetInstanceProcAddr)
 110     LOAD_FUNCPTR(vkGetPhysicalDeviceSurfaceCapabilitiesKHR)
 111     LOAD_FUNCPTR(vkGetPhysicalDeviceSurfaceFormatsKHR)
 112     LOAD_FUNCPTR(vkGetPhysicalDeviceSurfacePresentModesKHR)
 113     LOAD_FUNCPTR(vkGetPhysicalDeviceSurfaceSupportKHR)
 114     LOAD_FUNCPTR(vkGetSwapchainImagesKHR)
 115     LOAD_FUNCPTR(vkQueuePresentKHR)
 116 #undef LOAD_FUNCPTR
 117
 118     return TRUE;
 119
 120 fail:
 121     wine_dlclose(vulkan_handle, NULL, 0);
 122     vulkan_handle = NULL;
 123     return TRUE;
 124 }
 125
 126 /* Helper function for converting between win32 and MoltenVK compatible VkInstanceCreateInfo.
 127  * Caller is responsible for allocation and cleanup of 'dst'.
 128  */
 129 static VkResult wine_vk_instance_convert_create_info(const VkInstanceCreateInfo *src,
 130         VkInstanceCreateInfo *dst)
 131 {
 132     unsigned int i;
 133     const char **enabled_extensions = NULL;
 134
 135     dst->sType = src->sType;
 136     dst->flags = src->flags;
 137     dst->pApplicationInfo = src->pApplicationInfo;
 138     dst->pNext = src->pNext;
 139     dst->enabledLayerCount = 0;
 140     dst->ppEnabledLayerNames = NULL;
 141     dst->enabledExtensionCount = 0;
 142     dst->ppEnabledExtensionNames = NULL;
 143
 144     if (src->enabledExtensionCount > 0)
 145     {
 146         enabled_extensions = heap_calloc(src->enabledExtensionCount, sizeof(*src->ppEnabledExtensionNames));
 147         if (!enabled_extensions)
 148         {
 149             ERR("Failed to allocate memory for enabled extensions\n");
 150             return VK_ERROR_OUT_OF_HOST_MEMORY;
 151         }
 152
 153         for (i = 0; i < src->enabledExtensionCount; i++)
 154         {
 155             /* Substitute extension with MoltenVK ones else copy. Long-term, when we
 156              * support more extensions, we should store these in a list.
 157              */
 158             if (!strcmp(src->ppEnabledExtensionNames[i], "VK_KHR_win32_surface"))
 159             {
 160                 enabled_extensions[i] = "VK_MVK_macos_surface";
 161             }
 162             else
 163             {
 164                 enabled_extensions[i] = src->ppEnabledExtensionNames[i];
 165             }
 166         }
 167         dst->ppEnabledExtensionNames = enabled_extensions;
 168         dst->enabledExtensionCount = src->enabledExtensionCount;
 169     }
 170
 171     return VK_SUCCESS;
 172 }
 173
 174 static void wine_vk_surface_destroy(VkInstance instance, struct wine_vk_surface *surface)
 175 {
 176     /* vkDestroySurfaceKHR must handle VK_NULL_HANDLE (0) for surface. */
 177     if (!surface)
 178         return;
 179
 180     pvkDestroySurfaceKHR(instance, surface->surface, NULL /* allocator */);
 181
 182     if (surface->view)
 183         macdrv_view_release_metal_view(surface->view);
 184
 185     if (surface->device)
 186         macdrv_release_metal_device(surface->device);
 187
 188     heap_free(surface);
 189 }
 190
 191 static VkResult macdrv_vkCreateInstance(const VkInstanceCreateInfo *create_info,
 192         const VkAllocationCallbacks *allocator, VkInstance *instance)
 193 {
 194     VkInstanceCreateInfo create_info_host;
 195     VkResult res;
 196     TRACE("create_info %p, allocator %p, instance %p\n", create_info, allocator, instance);
 197
 198     if (allocator)
 199         FIXME("Support for allocation callbacks not implemented yet\n");
 200
 201     /* Perform a second pass on converting VkInstanceCreateInfo. Winevulkan
 202      * performed a first pass in which it handles everything except for WSI
 203      * functionality such as VK_KHR_win32_surface. Handle this now.
 204      */
 205     res = wine_vk_instance_convert_create_info(create_info, &create_info_host);
 206     if (res != VK_SUCCESS)
 207     {
 208         ERR("Failed to convert instance create info, res=%d\n", res);
 209         return res;
 210     }
 211
 212     res = pvkCreateInstance(&create_info_host, NULL /* allocator */, instance);
 213
 214     heap_free((void *)create_info_host.ppEnabledExtensionNames);
 215     return res;
 216 }
 217
 218 static VkResult macdrv_vkCreateSwapchainKHR(VkDevice device,
 219         const VkSwapchainCreateInfoKHR *create_info,
 220         const VkAllocationCallbacks *allocator, VkSwapchainKHR *swapchain)
 221 {
 222     VkSwapchainCreateInfoKHR create_info_host;
 223     TRACE("%p %p %p %p\n", device, create_info, allocator, swapchain);
 224
 225     if (allocator)
 226         FIXME("Support for allocation callbacks not implemented yet\n");
 227
 228     create_info_host = *create_info;
 229     create_info_host.surface = surface_from_handle(create_info->surface)->surface;
 230
 231     return pvkCreateSwapchainKHR(device, &create_info_host, NULL /* allocator */,
 232             swapchain);
 233 }
 234
 235 static VkResult macdrv_vkCreateWin32SurfaceKHR(VkInstance instance,
 236         const VkWin32SurfaceCreateInfoKHR *create_info,
 237         const VkAllocationCallbacks *allocator, VkSurfaceKHR *surface)
 238 {
 239     VkResult res;
 240     VkMacOSSurfaceCreateInfoMVK create_info_host;
 241     struct wine_vk_surface *mac_surface;
 242     struct macdrv_win_data *data;
 243
 244     TRACE("%p %p %p %p\n", instance, create_info, allocator, surface);
 245
 246     if (allocator)
 247         FIXME("Support for allocation callbacks not implemented yet\n");
 248
 249     if (!(data = get_win_data(create_info->hwnd)))
 250     {
 251         FIXME("DC for window %p of other process: not implemented\n", create_info->hwnd);
 252         return VK_ERROR_INCOMPATIBLE_DRIVER;
 253     }
 254
 255     mac_surface = heap_alloc_zero(sizeof(*mac_surface));
 256     if (!mac_surface)
 257     {
 258         release_win_data(data);
 259         return VK_ERROR_OUT_OF_HOST_MEMORY;
 260     }
 261
 262     mac_surface->device = macdrv_create_metal_device();
 263     if (!mac_surface->device)
 264     {
 265         ERR("Failed to allocate Metal device for hwnd=%p\n", create_info->hwnd);
 266         res = VK_ERROR_OUT_OF_HOST_MEMORY;
 267         goto err;
 268     }
 269
 270     mac_surface->view = macdrv_view_create_metal_view(data->client_cocoa_view, mac_surface->device);
 271     if (!mac_surface->view)
 272     {
 273         ERR("Failed to allocate Metal view for hwnd=%p\n", create_info->hwnd);
 274
 275         /* VK_KHR_win32_surface only allows out of host and device memory as errors. */
 276         res = VK_ERROR_OUT_OF_HOST_MEMORY;
 277         goto err;
 278     }
 279
 280     create_info_host.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
 281     create_info_host.pNext = NULL;
 282     create_info_host.flags = 0; /* reserved */
 283     create_info_host.pView = mac_surface->view;
 284
 285     res = pvkCreateMacOSSurfaceMVK(instance, &create_info_host, NULL /* allocator */, &mac_surface->surface);
 286     if (res != VK_SUCCESS)
 287     {
 288         ERR("Failed to create MoltenVK surface, res=%d\n", res);
 289         goto err;
 290     }
 291
 292     *surface = (uintptr_t)mac_surface;
 293
 294     release_win_data(data);
 295
 296     TRACE("Created surface=0x%s\n", wine_dbgstr_longlong(*surface));
 297     return VK_SUCCESS;
 298
 299 err:
 300     wine_vk_surface_destroy(instance, mac_surface);
 301     release_win_data(data);
 302     return res;
 303 }
 304
 305 static void macdrv_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *allocator)
 306 {
 307     TRACE("%p %p\n", instance, allocator);
 308
 309     if (allocator)
 310         FIXME("Support for allocation callbacks not implemented yet\n");
 311
 312     pvkDestroyInstance(instance, NULL /* allocator */);
 313 }
 314
 315 static void macdrv_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
 316         const VkAllocationCallbacks *allocator)
 317 {
 318     struct wine_vk_surface *mac_surface = surface_from_handle(surface);
 319
 320     TRACE("%p 0x%s %p\n", instance, wine_dbgstr_longlong(surface), allocator);
 321
 322     if (allocator)
 323         FIXME("Support for allocation callbacks not implemented yet\n");
 324
 325     wine_vk_surface_destroy(instance, mac_surface);
 326 }
 327
 328 static void macdrv_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
 329          const VkAllocationCallbacks *allocator)
 330 {
 331     TRACE("%p, 0x%s %p\n", device, wine_dbgstr_longlong(swapchain), allocator);
 332
 333     if (allocator)
 334         FIXME("Support for allocation callbacks not implemented yet\n");
 335
 336     pvkDestroySwapchainKHR(device, swapchain, NULL /* allocator */);
 337 }
 338
 339 static VkResult macdrv_vkEnumerateInstanceExtensionProperties(const char *layer_name,
 340         uint32_t *count, VkExtensionProperties* properties)
 341 {
 342     unsigned int i;
 343     VkResult res;
 344
 345     TRACE("layer_name %s, count %p, properties %p\n", debugstr_a(layer_name), count, properties);
 346
 347     /* This shouldn't get called with layer_name set, the ICD loader prevents it. */
 348     if (layer_name)
 349     {
 350         ERR("Layer enumeration not supported from ICD.\n");
 351         return VK_ERROR_LAYER_NOT_PRESENT;
 352     }
 353
 354     /* We will return the same number of instance extensions reported by the host back to
 355      * winevulkan. Along the way we may replace MoltenVK extensions with their win32 equivalents.
 356      * Winevulkan will perform more detailed filtering as it knows whether it has thunks
 357      * for a particular extension.
 358      */
 359     res = pvkEnumerateInstanceExtensionProperties(layer_name, count, properties);
 360     if (!properties || res < 0)
 361         return res;
 362
 363     for (i = 0; i < *count; i++)
 364     {
 365         /* For now the only MoltenVK extension we need to fixup. Long-term we may need an array. */
 366         if (!strcmp(properties[i].extensionName, "VK_MVK_macos_surface"))
 367         {
 368             TRACE("Substituting VK_MVK_macos_surface for VK_KHR_win32_surface\n");
 369
 370             snprintf(properties[i].extensionName, sizeof(properties[i].extensionName),
 371                     VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
 372             properties[i].specVersion = VK_KHR_WIN32_SURFACE_SPEC_VERSION;
 373         }
 374     }
 375
 376     TRACE("Returning %u extensions.\n", *count);
 377     return res;
 378 }
 379
 380 static void *macdrv_vkGetDeviceProcAddr(VkDevice device, const char *name)
 381 {
 382     void *proc_addr;
 383
 384     TRACE("%p, %s\n", device, debugstr_a(name));
 385
 386     if ((proc_addr = macdrv_get_vk_device_proc_addr(name)))
 387         return proc_addr;
 388
 389     return pvkGetDeviceProcAddr(device, name);
 390 }
 391
 392 static void *macdrv_vkGetInstanceProcAddr(VkInstance instance, const char *name)
 393 {
 394     void *proc_addr;
 395
 396     TRACE("%p, %s\n", instance, debugstr_a(name));
 397
 398     if ((proc_addr = macdrv_get_vk_instance_proc_addr(instance, name)))
 399         return proc_addr;
 400
 401     return pvkGetInstanceProcAddr(instance, name);
 402 }
 403
 404 static VkResult macdrv_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice phys_dev,
 405         VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *capabilities)
 406 {
 407     struct wine_vk_surface *mac_surface = surface_from_handle(surface);
 408
 409     TRACE("%p, 0x%s, %p\n", phys_dev, wine_dbgstr_longlong(surface), capabilities);
 410
 411     return pvkGetPhysicalDeviceSurfaceCapabilitiesKHR(phys_dev, mac_surface->surface,
 412             capabilities);
 413 }
 414
 415 static VkResult macdrv_vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice phys_dev,
 416         VkSurfaceKHR surface, uint32_t *count, VkSurfaceFormatKHR *formats)
 417 {
 418     struct wine_vk_surface *mac_surface = surface_from_handle(surface);
 419
 420     TRACE("%p, 0x%s, %p, %p\n", phys_dev, wine_dbgstr_longlong(surface), count, formats);
 421
 422     return pvkGetPhysicalDeviceSurfaceFormatsKHR(phys_dev, mac_surface->surface,
 423             count, formats);
 424 }
 425
 426 static VkResult macdrv_vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice phys_dev,
 427         VkSurfaceKHR surface, uint32_t *count, VkPresentModeKHR *modes)
 428 {
 429     struct wine_vk_surface *mac_surface = surface_from_handle(surface);
 430
 431     TRACE("%p, 0x%s, %p, %p\n", phys_dev, wine_dbgstr_longlong(surface), count, modes);
 432
 433     return pvkGetPhysicalDeviceSurfacePresentModesKHR(phys_dev, mac_surface->surface, count,
 434             modes);
 435 }
 436
 437 static VkResult macdrv_vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice phys_dev,
 438         uint32_t index, VkSurfaceKHR surface, VkBool32 *supported)
 439 {
 440     struct wine_vk_surface *mac_surface = surface_from_handle(surface);
 441
 442     TRACE("%p, %u, 0x%s, %p\n", phys_dev, index, wine_dbgstr_longlong(surface), supported);
 443
 444     return pvkGetPhysicalDeviceSurfaceSupportKHR(phys_dev, index, mac_surface->surface,
 445             supported);
 446 }
 447
 448 static VkBool32 macdrv_vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice phys_dev,
 449         uint32_t index)
 450 {
 451     TRACE("%p %u\n", phys_dev, index);
 452
 453     return VK_TRUE;
 454 }
 455
 456 static VkResult macdrv_vkGetSwapchainImagesKHR(VkDevice device,
 457         VkSwapchainKHR swapchain, uint32_t *count, VkImage *images)
 458 {
 459     TRACE("%p, 0x%s %p %p\n", device, wine_dbgstr_longlong(swapchain), count, images);
 460     return pvkGetSwapchainImagesKHR(device, swapchain, count, images);
 461 }
 462
 463 static VkResult macdrv_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *present_info)
 464 {
 465     TRACE("%p, %p\n", queue, present_info);
 466     return pvkQueuePresentKHR(queue, present_info);
 467 }
 468
 469 static const struct vulkan_funcs vulkan_funcs =
 470 {
 471     macdrv_vkCreateInstance,
 472     macdrv_vkCreateSwapchainKHR,
 473     macdrv_vkCreateWin32SurfaceKHR,
 474     macdrv_vkDestroyInstance,
 475     macdrv_vkDestroySurfaceKHR,
 476     macdrv_vkDestroySwapchainKHR,
 477     macdrv_vkEnumerateInstanceExtensionProperties,
 478     NULL,
 479     macdrv_vkGetDeviceProcAddr,
 480     macdrv_vkGetInstanceProcAddr,
 481     NULL,
 482     macdrv_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
 483     macdrv_vkGetPhysicalDeviceSurfaceFormatsKHR,
 484     macdrv_vkGetPhysicalDeviceSurfacePresentModesKHR,
 485     macdrv_vkGetPhysicalDeviceSurfaceSupportKHR,
 486     macdrv_vkGetPhysicalDeviceWin32PresentationSupportKHR,
 487     macdrv_vkGetSwapchainImagesKHR,
 488     macdrv_vkQueuePresentKHR,
 489 };
 490
 491 static void *macdrv_get_vk_device_proc_addr(const char *name)
 492 {
 493     return get_vulkan_driver_device_proc_addr(&vulkan_funcs, name);
 494 }
 495
 496 static void *macdrv_get_vk_instance_proc_addr(VkInstance instance, const char *name)
 497 {
 498     return get_vulkan_driver_instance_proc_addr(&vulkan_funcs, instance, name);
 499 }
 500
 501 static const struct vulkan_funcs *get_vulkan_driver(UINT version)
 502 {
 503     static INIT_ONCE init_once = INIT_ONCE_STATIC_INIT;
 504
 505     if (version != WINE_VULKAN_DRIVER_VERSION)
 506     {
 507         ERR("version mismatch, vulkan wants %u but driver has %u\n", version, WINE_VULKAN_DRIVER_VERSION);
 508         return NULL;
 509     }
 510
 511     InitOnceExecuteOnce(&init_once, wine_vk_init, NULL, NULL);
 512     if (vulkan_handle)
 513         return &vulkan_funcs;
 514
 515     return NULL;
 516 }
 517
 518 #else /* No vulkan */
 519
 520 static const struct vulkan_funcs *get_vulkan_driver(UINT version)
 521 {
 522     ERR("Wine was built without Vulkan support.\n");
 523     return NULL;
 524 }
 525
 526 #endif /* SONAME_LIBMOLTENVK */
 527
 528 const struct vulkan_funcs *macdrv_wine_get_vulkan_driver(PHYSDEV dev, UINT version)
 529 {
 530     const struct vulkan_funcs *ret;
 531
 532     if (!(ret = get_vulkan_driver( version )))
 533     {
 534         dev = GET_NEXT_PHYSDEV( dev, wine_get_vulkan_driver );
 535         ret = dev->funcs->wine_get_vulkan_driver( dev, version );
 536     }
 537     return ret;
 538 }