niansa-misc/wine
1
0
Fork 0
mirror of synced 2025-03-07 03:53:26 +01:00
Code Issues Projects Releases Packages Wiki Activity

win32u: Move D3DKMT vulkan implementation out of winex11.

Browse source
This commit is contained in:
Rémi Bernon 2024-03-14 10:11:22 +01:00 • committed by Alexandre Julliard
parent dc9229e6fa
commit 4573910acc
13 changed files with 173 additions and 405 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

177
dlls/win32u/d3dkmt.c
View file

@ -59,6 +59,70 @@ static struct list d3dkmt_adapters = LIST_INIT( d3dkmt_adapters );
static struct list d3dkmt_devices = LIST_INIT( d3dkmt_devices );
static struct list d3dkmt_vidpn_sources = LIST_INIT( d3dkmt_vidpn_sources ); /* VidPN source information list */
static VkInstance d3dkmt_vk_instance; /* Vulkan instance for D3DKMT functions */
static PFN_vkGetPhysicalDeviceMemoryProperties2KHR pvkGetPhysicalDeviceMemoryProperties2KHR;
static PFN_vkGetPhysicalDeviceProperties2KHR pvkGetPhysicalDeviceProperties2KHR;
static PFN_vkEnumeratePhysicalDevices pvkEnumeratePhysicalDevices;
static const struct vulkan_funcs *vulkan_funcs;
static void d3dkmt_init_vulkan(void)
{
static const char *extensions[] =
{
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME,
};
VkInstanceCreateInfo create_info =
{
.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
.enabledExtensionCount = ARRAY_SIZE( extensions ),
.ppEnabledExtensionNames = extensions,
};
VkResult vr;
if (!(vulkan_funcs = __wine_get_vulkan_driver( WINE_VULKAN_DRIVER_VERSION )))
{
WARN( "Failed to open the Vulkan driver\n" );
return;
}
if ((vr = vulkan_funcs->p_vkCreateInstance( &create_info, NULL, &d3dkmt_vk_instance )))
{
WARN( "Failed to create a Vulkan instance, vr %d.\n", vr );
vulkan_funcs = NULL;
return;
}
#define LOAD_VK_FUNC( f ) \
if (!(p##f = (void *)vulkan_funcs->p_vkGetInstanceProcAddr( d3dkmt_vk_instance, #f ))) \
{ \
WARN( "Failed to load " #f ".\n" ); \
vulkan_funcs->p_vkDestroyInstance( d3dkmt_vk_instance, NULL ); \
vulkan_funcs = NULL; \
return; \
}
LOAD_VK_FUNC( vkEnumeratePhysicalDevices )
LOAD_VK_FUNC( vkGetPhysicalDeviceProperties2KHR )
LOAD_VK_FUNC( vkGetPhysicalDeviceMemoryProperties2KHR )
#undef LOAD_VK_FUNC
}
static BOOL d3dkmt_use_vulkan(void)
{
static pthread_once_t once = PTHREAD_ONCE_INIT;
pthread_once( &once, d3dkmt_init_vulkan );
return !!vulkan_funcs;
}
/* d3dkmt_lock must be held */
static struct d3dkmt_adapter *find_adapter_from_handle( D3DKMT_HANDLE handle )
{
struct d3dkmt_adapter *adapter;
LIST_FOR_EACH_ENTRY( adapter, &d3dkmt_adapters, struct d3dkmt_adapter, entry )
if (adapter->handle == handle) return adapter;
return NULL;
}
/******************************************************************************
* NtGdiDdDDIOpenAdapterFromHdc (win32u.@)
*/
@ -89,22 +153,15 @@ NTSTATUS WINAPI NtGdiDdDDICloseAdapter( const D3DKMT_CLOSEADAPTER *desc )
if (!desc || !desc->hAdapter) return STATUS_INVALID_PARAMETER;
if (get_display_driver()->pD3DKMTCloseAdapter)
get_display_driver()->pD3DKMTCloseAdapter( desc );
pthread_mutex_lock( &d3dkmt_lock );
LIST_FOR_EACH_ENTRY( adapter, &d3dkmt_adapters, struct d3dkmt_adapter, entry )
if ((adapter = find_adapter_from_handle( desc->hAdapter )))
{
if (adapter->handle == desc->hAdapter)
{
list_remove( &adapter->entry );
free( adapter );
status = STATUS_SUCCESS;
break;
}
list_remove( &adapter->entry );
status = STATUS_SUCCESS;
}
pthread_mutex_unlock( &d3dkmt_lock );
free( adapter );
return status;
}
@ -128,6 +185,45 @@ NTSTATUS WINAPI NtGdiDdDDIOpenAdapterFromDeviceName( D3DKMT_OPENADAPTERFROMDEVIC
return STATUS_SUCCESS;
}
static VkPhysicalDevice get_vulkan_physical_device( const GUID *uuid )
{
VkPhysicalDevice *devices, device;
UINT device_count, i;
VkResult vr;
if ((vr = pvkEnumeratePhysicalDevices( d3dkmt_vk_instance, &device_count, NULL )))
{
WARN( "vkEnumeratePhysicalDevices returned %d\n", vr );
return VK_NULL_HANDLE;
}
if (!device_count || !(devices = malloc( device_count * sizeof(*devices) )))
return VK_NULL_HANDLE;
if ((vr = pvkEnumeratePhysicalDevices( d3dkmt_vk_instance, &device_count, devices )))
{
WARN( "vkEnumeratePhysicalDevices returned %d\n", vr );
free( devices );
return VK_NULL_HANDLE;
}
for (i = 0, device = VK_NULL_HANDLE; i < device_count; ++i)
{
VkPhysicalDeviceIDProperties id = {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES};
VkPhysicalDeviceProperties2 properties2 = {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, .pNext = &id};
pvkGetPhysicalDeviceProperties2KHR( devices[i], &properties2 );
if (IsEqualGUID( uuid, id.deviceUUID ))
{
device = devices[i];
break;
}
}
free( devices );
return device;
}
/******************************************************************************
* NtGdiDdDDIOpenAdapterFromLuid (win32u.@)
*/
@ -135,17 +231,23 @@ NTSTATUS WINAPI NtGdiDdDDIOpenAdapterFromLuid( D3DKMT_OPENADAPTERFROMLUID *desc
{
static D3DKMT_HANDLE handle_start = 0;
struct d3dkmt_adapter *adapter;
GUID uuid = {0};
if (!(adapter = malloc( sizeof(*adapter) ))) return STATUS_NO_MEMORY;
if (!(adapter = calloc( 1, sizeof(*adapter) ))) return STATUS_NO_MEMORY;
if (!d3dkmt_use_vulkan())
WARN( "Vulkan is unavailable.\n" );
else if (!get_vulkan_uuid_from_luid( &desc->AdapterLuid, &uuid ))
WARN( "Failed to find Vulkan device with LUID %08x:%08x.\n",
(int)desc->AdapterLuid.HighPart, (int)desc->AdapterLuid.LowPart );
else if (!(adapter->vk_device = get_vulkan_physical_device( &uuid )))
WARN( "Failed to find vulkan device with GUID %s\n", debugstr_guid( &uuid ) );
pthread_mutex_lock( &d3dkmt_lock );
desc->hAdapter = adapter->handle = ++handle_start;
list_add_tail( &d3dkmt_adapters, &adapter->entry );
pthread_mutex_unlock( &d3dkmt_lock );
if (get_display_driver()->pD3DKMTOpenAdapterFromLuid)
get_display_driver()->pD3DKMTOpenAdapterFromLuid( desc );
return STATUS_SUCCESS;
}
@ -155,7 +257,6 @@ NTSTATUS WINAPI NtGdiDdDDIOpenAdapterFromLuid( D3DKMT_OPENADAPTERFROMLUID *desc
NTSTATUS WINAPI NtGdiDdDDICreateDevice( D3DKMT_CREATEDEVICE *desc )
{
static D3DKMT_HANDLE handle_start = 0;
struct d3dkmt_adapter *adapter;
struct d3dkmt_device *device;
BOOL found = FALSE;
@ -164,14 +265,7 @@ NTSTATUS WINAPI NtGdiDdDDICreateDevice( D3DKMT_CREATEDEVICE *desc )
if (!desc) return STATUS_INVALID_PARAMETER;
pthread_mutex_lock( &d3dkmt_lock );
LIST_FOR_EACH_ENTRY( adapter, &d3dkmt_adapters, struct d3dkmt_adapter, entry )
{
if (adapter->handle == desc->hAdapter)
{
found = TRUE;
break;
}
}
found = !!find_adapter_from_handle( desc->hAdapter );
pthread_mutex_unlock( &d3dkmt_lock );
if (!found) return STATUS_INVALID_PARAMETER;
@ -248,8 +342,12 @@ NTSTATUS WINAPI NtGdiDdDDIQueryStatistics( D3DKMT_QUERYSTATISTICS *stats )
*/
NTSTATUS WINAPI NtGdiDdDDIQueryVideoMemoryInfo( D3DKMT_QUERYVIDEOMEMORYINFO *desc )
{
VkPhysicalDeviceMemoryBudgetPropertiesEXT budget;
VkPhysicalDeviceMemoryProperties2 properties2;
struct d3dkmt_adapter *adapter;
OBJECT_BASIC_INFORMATION info;
NTSTATUS status;
unsigned int i;
TRACE( "(%p)\n", desc );
@ -266,8 +364,35 @@ NTSTATUS WINAPI NtGdiDdDDIQueryVideoMemoryInfo( D3DKMT_QUERYVIDEOMEMORYINFO *des
if (status != STATUS_SUCCESS) return status;
if (!(info.GrantedAccess & PROCESS_QUERY_INFORMATION)) return STATUS_ACCESS_DENIED;
if (!get_display_driver()->pD3DKMTQueryVideoMemoryInfo) return STATUS_PROCEDURE_NOT_FOUND;
return get_display_driver()->pD3DKMTQueryVideoMemoryInfo( desc );
desc->Budget = 0;
desc->CurrentUsage = 0;
desc->CurrentReservation = 0;
desc->AvailableForReservation = 0;
pthread_mutex_lock( &d3dkmt_lock );
if ((adapter = find_adapter_from_handle( desc->hAdapter )) && adapter->vk_device)
{
memset( &budget, 0, sizeof(budget) );
budget.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
properties2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
properties2.pNext = &budget;
pvkGetPhysicalDeviceMemoryProperties2KHR( adapter->vk_device, &properties2 );
for (i = 0; i < properties2.memoryProperties.memoryHeapCount; ++i)
{
if ((desc->MemorySegmentGroup == D3DKMT_MEMORY_SEGMENT_GROUP_LOCAL &&
properties2.memoryProperties.memoryHeaps[i].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) ||
(desc->MemorySegmentGroup == D3DKMT_MEMORY_SEGMENT_GROUP_NON_LOCAL &&
!(properties2.memoryProperties.memoryHeaps[i].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)))
{
desc->Budget += budget.heapBudget[i];
desc->CurrentUsage += budget.heapUsage[i];
}
}
desc->AvailableForReservation = desc->Budget / 2;
}
pthread_mutex_unlock( &d3dkmt_lock );
return adapter ? STATUS_SUCCESS : STATUS_INVALID_PARAMETER;
}
/******************************************************************************

6
dlls/win32u/dibdrv/dc.c
View file

@ -707,9 +707,6 @@ const struct gdi_dc_funcs dib_driver =
dibdrv_StrokeAndFillPath, /* pStrokeAndFillPath */
dibdrv_StrokePath, /* pStrokePath */
NULL, /* pUnrealizePalette */
NULL, /* pD3DKMTCloseAdapter */
NULL, /* pD3DKMTOpenAdapterFromLuid */
NULL, /* pD3DKMTQueryVideoMemoryInfo */
GDI_PRIORITY_DIB_DRV /* priority */
};
@ -1266,8 +1263,5 @@ static const struct gdi_dc_funcs window_driver =
NULL, /* pStrokeAndFillPath */
NULL, /* pStrokePath */
NULL, /* pUnrealizePalette */
NULL, /* pD3DKMTCloseAdapter */
NULL, /* pD3DKMTOpenAdapterFromLuid */
NULL, /* pD3DKMTQueryVideoMemoryInfo */
GDI_PRIORITY_DIB_DRV + 10 /* priority */
};

18
dlls/win32u/driver.c
View file

@ -522,21 +522,6 @@ static BOOL nulldrv_UnrealizePalette( HPALETTE palette )
return FALSE;
}
static NTSTATUS nulldrv_D3DKMTCloseAdapter( const D3DKMT_CLOSEADAPTER *desc )
{
return STATUS_PROCEDURE_NOT_FOUND;
}
static NTSTATUS nulldrv_D3DKMTOpenAdapterFromLuid( D3DKMT_OPENADAPTERFROMLUID *desc )
{
return STATUS_PROCEDURE_NOT_FOUND;
}
static NTSTATUS nulldrv_D3DKMTQueryVideoMemoryInfo( D3DKMT_QUERYVIDEOMEMORYINFO *desc )
{
return STATUS_PROCEDURE_NOT_FOUND;
}
const struct gdi_dc_funcs null_driver =
{
nulldrv_AbortDoc, /* pAbortDoc */
@ -628,9 +613,6 @@ const struct gdi_dc_funcs null_driver =
nulldrv_StrokeAndFillPath, /* pStrokeAndFillPath */
nulldrv_StrokePath, /* pStrokePath */
nulldrv_UnrealizePalette, /* pUnrealizePalette */
nulldrv_D3DKMTCloseAdapter, /* pD3DKMTCloseAdapter */
nulldrv_D3DKMTOpenAdapterFromLuid, /* pD3DKMTOpenAdapterFromLuid */
nulldrv_D3DKMTQueryVideoMemoryInfo, /* pD3DKMTQueryVideoMemoryInfo */
GDI_PRIORITY_NULL_DRV /* priority */
};

3
dlls/win32u/emfdrv.c
View file

@ -519,9 +519,6 @@ static const struct gdi_dc_funcs emfdrv_driver =
EMFDRV_StrokeAndFillPath, /* pStrokeAndFillPath */
EMFDRV_StrokePath, /* pStrokePath */
NULL, /* pUnrealizePalette */
NULL, /* pD3DKMTCloseAdapter */
NULL, /* pD3DKMTOpenAdapterFromLuid */
NULL, /* pD3DKMTQueryVideoMemoryInfo */
GDI_PRIORITY_GRAPHICS_DRV /* priority */
};

3
dlls/win32u/font.c
View file

@ -4785,9 +4785,6 @@ const struct gdi_dc_funcs font_driver =
NULL, /* pStrokeAndFillPath */
NULL, /* pStrokePath */
NULL, /* pUnrealizePalette */
NULL, /* pD3DKMTCloseAdapter */
NULL, /* pD3DKMTOpenAdapterFromLuid */
NULL, /* pD3DKMTQueryVideoMemoryInfo */
GDI_PRIORITY_FONT_DRV /* priority */
};

3
dlls/win32u/path.c
View file

@ -2118,8 +2118,5 @@ const struct gdi_dc_funcs path_driver =
NULL, /* pStrokeAndFillPath */
NULL, /* pStrokePath */
NULL, /* pUnrealizePalette */
NULL, /* pD3DKMTCloseAdapter */
NULL, /* pD3DKMTOpenAdapterFromLuid */
NULL, /* pD3DKMTQueryVideoMemoryInfo */
GDI_PRIORITY_PATH_DRV /* priority */
};

21
dlls/win32u/sysparams.c
View file

@ -6681,3 +6681,24 @@ done:
while (count) gpu_release( current_gpus[--count] );
return status;
}
/* Find the Vulkan device UUID corresponding to a LUID */
BOOL get_vulkan_uuid_from_luid( const LUID *luid, GUID *uuid )
{
BOOL found = FALSE;
struct gpu *gpu;
if (!lock_display_devices()) return FALSE;
LIST_FOR_EACH_ENTRY( gpu, &gpus, struct gpu, entry )
{
if ((found = !memcmp( &gpu->luid, luid, sizeof(*luid) )))
{
*uuid = gpu->vulkan_uuid;
break;
}
}
unlock_display_devices();
return found;
}

1
dlls/win32u/win32u_private.h
View file

@ -191,6 +191,7 @@ extern BOOL update_display_cache( BOOL force );
extern void user_lock(void);
extern void user_unlock(void);
extern void user_check_not_lock(void);
extern BOOL get_vulkan_uuid_from_luid( const LUID *luid, GUID *uuid );
/* winstation.c */
extern BOOL is_virtual_desktop(void);

3
dlls/winex11.drv/init.c
View file

@ -376,9 +376,6 @@ static const struct user_driver_funcs x11drv_funcs =
.dc_funcs.pStrokeAndFillPath = X11DRV_StrokeAndFillPath,
.dc_funcs.pStrokePath = X11DRV_StrokePath,
.dc_funcs.pUnrealizePalette = X11DRV_UnrealizePalette,
.dc_funcs.pD3DKMTCloseAdapter = X11DRV_D3DKMTCloseAdapter,
.dc_funcs.pD3DKMTOpenAdapterFromLuid = X11DRV_D3DKMTOpenAdapterFromLuid,
.dc_funcs.pD3DKMTQueryVideoMemoryInfo = X11DRV_D3DKMTQueryVideoMemoryInfo,
.dc_funcs.priority = GDI_PRIORITY_GRAPHICS_DRV,
.pActivateKeyboardLayout = X11DRV_ActivateKeyboardLayout,

3
dlls/winex11.drv/x11drv.h
View file

@ -158,9 +158,6 @@ extern BOOL X11DRV_Arc( PHYSDEV dev, INT left, INT top, INT right,
INT bottom, INT xstart, INT ystart, INT xend, INT yend );
extern BOOL X11DRV_Chord( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
INT xstart, INT ystart, INT xend, INT yend );
extern NTSTATUS X11DRV_D3DKMTCloseAdapter( const D3DKMT_CLOSEADAPTER *desc );
extern NTSTATUS X11DRV_D3DKMTOpenAdapterFromLuid( D3DKMT_OPENADAPTERFROMLUID *desc );
extern NTSTATUS X11DRV_D3DKMTQueryVideoMemoryInfo( D3DKMT_QUERYVIDEOMEMORYINFO *desc );
extern BOOL X11DRV_Ellipse( PHYSDEV dev, INT left, INT top, INT right, INT bottom );
extern BOOL X11DRV_ExtFloodFill( PHYSDEV dev, INT x, INT y, COLORREF color, UINT fillType );
extern BOOL X11DRV_FillPath( PHYSDEV dev );

334
dlls/winex11.drv/x11drv_main.c
View file

@ -97,73 +97,8 @@ static int (*old_error_handler)( Display *, XErrorEvent * );
static BOOL use_xim = TRUE;
static WCHAR input_style[20];
static pthread_mutex_t d3dkmt_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t error_mutex = PTHREAD_MUTEX_INITIALIZER;
struct x11_d3dkmt_adapter
{
D3DKMT_HANDLE handle; /* Kernel mode graphics adapter handle */
VkPhysicalDevice vk_device; /* Vulkan physical device */
struct list entry; /* List entry */
};
static struct list x11_d3dkmt_adapters = LIST_INIT( x11_d3dkmt_adapters );
static VkInstance d3dkmt_vk_instance; /* Vulkan instance for D3DKMT functions */
static PFN_vkGetPhysicalDeviceMemoryProperties2KHR pvkGetPhysicalDeviceMemoryProperties2KHR;
static PFN_vkGetPhysicalDeviceProperties2KHR pvkGetPhysicalDeviceProperties2KHR;
static PFN_vkEnumeratePhysicalDevices pvkEnumeratePhysicalDevices;
static const struct vulkan_funcs *vulkan_funcs;
static void d3dkmt_init_vulkan(void)
{
static const char *extensions[] =
{
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME,
};
VkInstanceCreateInfo create_info =
{
.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
.enabledExtensionCount = ARRAY_SIZE( extensions ),
.ppEnabledExtensionNames = extensions,
};
VkResult vr;
if (!(vulkan_funcs = __wine_get_vulkan_driver( WINE_VULKAN_DRIVER_VERSION )))
{
WARN( "Failed to open the Vulkan driver\n" );
return;
}
if ((vr = vulkan_funcs->p_vkCreateInstance( &create_info, NULL, &d3dkmt_vk_instance )))
{
WARN( "Failed to create a Vulkan instance, vr %d.\n", vr );
vulkan_funcs = NULL;
return;
}
#define LOAD_VK_FUNC( f ) \
if (!(p##f = (void *)vulkan_funcs->p_vkGetInstanceProcAddr( d3dkmt_vk_instance, #f ))) \
{ \
WARN( "Failed to load " #f ".\n" ); \
vulkan_funcs->p_vkDestroyInstance( d3dkmt_vk_instance, NULL ); \
vulkan_funcs = NULL; \
return; \
}
LOAD_VK_FUNC( vkEnumeratePhysicalDevices )
LOAD_VK_FUNC( vkGetPhysicalDeviceProperties2KHR )
LOAD_VK_FUNC( vkGetPhysicalDeviceMemoryProperties2KHR )
#undef LOAD_VK_FUNC
}
static BOOL d3dkmt_use_vulkan(void)
{
static pthread_once_t once = PTHREAD_ONCE_INIT;
pthread_once( &once, d3dkmt_init_vulkan );
return !!vulkan_funcs;
}
#define IS_OPTION_TRUE(ch) \
((ch) == 'y' || (ch) == 'Y' || (ch) == 't' || (ch) == 'T' || (ch) == '1')
#define IS_OPTION_FALSE(ch) \
@ -871,275 +806,6 @@ BOOL X11DRV_SystemParametersInfo( UINT action, UINT int_param, void *ptr_param,
return FALSE; /* let user32 handle it */
}
/* d3dkmt_lock must be held */
static struct x11_d3dkmt_adapter *find_adapter_from_handle( D3DKMT_HANDLE handle )
{
struct x11_d3dkmt_adapter *adapter;
LIST_FOR_EACH_ENTRY( adapter, &x11_d3dkmt_adapters, struct x11_d3dkmt_adapter, entry )
if (adapter->handle == handle) return adapter;
return NULL;
}
NTSTATUS X11DRV_D3DKMTCloseAdapter( const D3DKMT_CLOSEADAPTER *desc )
{
struct x11_d3dkmt_adapter *adapter;
if (!d3dkmt_use_vulkan())
return STATUS_UNSUCCESSFUL;
pthread_mutex_lock(&d3dkmt_mutex);
if ((adapter = find_adapter_from_handle( desc->hAdapter )))
list_remove( &adapter->entry );
pthread_mutex_unlock(&d3dkmt_mutex);
free(adapter);
return STATUS_SUCCESS;
}
static HANDLE get_display_device_init_mutex(void)
{
WCHAR bufferW[256];
UNICODE_STRING name = {.Buffer = bufferW};
OBJECT_ATTRIBUTES attr;
char buffer[256];
HANDLE mutex;
snprintf( buffer, ARRAY_SIZE(buffer), "\\Sessions\\%u\\BaseNamedObjects\\display_device_init",
(int)NtCurrentTeb()->Peb->SessionId );
name.MaximumLength = asciiz_to_unicode( bufferW, buffer );
name.Length = name.MaximumLength - sizeof(WCHAR);
InitializeObjectAttributes( &attr, &name, OBJ_OPENIF, NULL, NULL );
if (NtCreateMutant( &mutex, MUTEX_ALL_ACCESS, &attr, FALSE ) < 0) return 0;
NtWaitForSingleObject( mutex, FALSE, NULL );
return mutex;
}
static void release_display_device_init_mutex(HANDLE mutex)
{
NtReleaseMutant( mutex, NULL );
NtClose( mutex );
}
/* Find the Vulkan device UUID corresponding to a LUID */
static BOOL get_vulkan_uuid_from_luid( const LUID *luid, GUID *uuid )
{
static const WCHAR class_guidW[] = {'C','l','a','s','s','G','U','I','D',0};
static const WCHAR devpropkey_gpu_vulkan_uuidW[] =
{
'P','r','o','p','e','r','t','i','e','s',
'\\','{','2','3','3','A','9','E','F','3','-','A','F','C','4','-','4','A','B','D',
'-','B','5','6','4','-','C','3','2','F','2','1','F','1','5','3','5','C','}',
'\\','0','0','0','2'
};
static const WCHAR devpropkey_gpu_luidW[] =
{
'P','r','o','p','e','r','t','i','e','s',
'\\','{','6','0','B','1','9','3','C','B','-','5','2','7','6','-','4','D','0','F',
'-','9','6','F','C','-','F','1','7','3','A','B','A','D','3','E','C','6','}',
'\\','0','0','0','2'
};
static const WCHAR guid_devclass_displayW[] =
{'{','4','D','3','6','E','9','6','8','-','E','3','2','5','-','1','1','C','E','-',
'B','F','C','1','-','0','8','0','0','2','B','E','1','0','3','1','8','}',0};
static const WCHAR pci_keyW[] =
{
'\\','R','e','g','i','s','t','r','y',
'\\','M','a','c','h','i','n','e',
'\\','S','y','s','t','e','m',
'\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t',
'\\','E','n','u','m',
'\\','P','C','I'
};
char buffer[4096];
KEY_VALUE_PARTIAL_INFORMATION *value = (void *)buffer;
HKEY subkey, device_key, prop_key, pci_key;
KEY_NODE_INFORMATION *key = (void *)buffer;
DWORD size, i = 0;
HANDLE mutex;
mutex = get_display_device_init_mutex();
pci_key = reg_open_key(NULL, pci_keyW, sizeof(pci_keyW));
while (!NtEnumerateKey(pci_key, i++, KeyNodeInformation, key, sizeof(buffer), &size))
{
unsigned int j = 0;
if (!(subkey = reg_open_key(pci_key, key->Name, key->NameLength)))
continue;
while (!NtEnumerateKey(subkey, j++, KeyNodeInformation, key, sizeof(buffer), &size))
{
if (!(device_key = reg_open_key(subkey, key->Name, key->NameLength)))
continue;
size = query_reg_value(device_key, class_guidW, value, sizeof(buffer));
if (size != sizeof(guid_devclass_displayW) ||
wcscmp((WCHAR *)value->Data, guid_devclass_displayW))
{
NtClose(device_key);
continue;
}
if (!(prop_key = reg_open_key(device_key, devpropkey_gpu_luidW,
sizeof(devpropkey_gpu_luidW))))
{
NtClose(device_key);
continue;
}
size = query_reg_value(prop_key, NULL, value, sizeof(buffer));
NtClose(prop_key);
if (size != sizeof(LUID) || memcmp(value->Data, luid, sizeof(LUID)))
{
NtClose(device_key);
continue;
}
if (!(prop_key = reg_open_key(device_key, devpropkey_gpu_vulkan_uuidW,
sizeof(devpropkey_gpu_vulkan_uuidW))))
{
NtClose(device_key);
continue;
}
size = query_reg_value(prop_key, NULL, value, sizeof(buffer));
NtClose(prop_key);
if (size != sizeof(GUID))
{
NtClose(device_key);
continue;
}
*uuid = *(const GUID *)value->Data;
NtClose(device_key);
NtClose(subkey);
NtClose(pci_key);
release_display_device_init_mutex(mutex);
return TRUE;
}
NtClose(subkey);
}
NtClose(pci_key);
release_display_device_init_mutex(mutex);
return FALSE;
}
static VkPhysicalDevice get_vulkan_physical_device( const GUID *uuid )
{
VkPhysicalDevice *devices, device;
UINT device_count, i;
VkResult vr;
if ((vr = pvkEnumeratePhysicalDevices( d3dkmt_vk_instance, &device_count, NULL )))
{
WARN( "vkEnumeratePhysicalDevices returned %d\n", vr );
return VK_NULL_HANDLE;
}
if (!device_count || !(devices = malloc( device_count * sizeof(*devices) )))
return VK_NULL_HANDLE;
if ((vr = pvkEnumeratePhysicalDevices( d3dkmt_vk_instance, &device_count, devices )))
{
WARN( "vkEnumeratePhysicalDevices returned %d\n", vr );
free( devices );
return VK_NULL_HANDLE;
}
for (i = 0, device = VK_NULL_HANDLE; i < device_count; ++i)
{
VkPhysicalDeviceIDProperties id = {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES};
VkPhysicalDeviceProperties2 properties2 = {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, .pNext = &id};
pvkGetPhysicalDeviceProperties2KHR( devices[i], &properties2 );
if (IsEqualGUID( uuid, id.deviceUUID ))
{
device = devices[i];
break;
}
}
free( devices );
return device;
}
NTSTATUS X11DRV_D3DKMTOpenAdapterFromLuid( D3DKMT_OPENADAPTERFROMLUID *desc )
{
VkPhysicalDevice device;
struct x11_d3dkmt_adapter *adapter;
GUID uuid;
if (!get_vulkan_uuid_from_luid(&desc->AdapterLuid, &uuid))
{
WARN("Failed to find Vulkan device with LUID %08x:%08x.\n",
(int)desc->AdapterLuid.HighPart, (int)desc->AdapterLuid.LowPart);
return STATUS_INVALID_PARAMETER;
}
/* Find the Vulkan device with corresponding UUID */
if (!d3dkmt_use_vulkan())
{
WARN("Vulkan is unavailable.\n");
return STATUS_UNSUCCESSFUL;
}
if (!(device = get_vulkan_physical_device( &uuid ))) return STATUS_UNSUCCESSFUL;
if (!(adapter = malloc( sizeof(*adapter) ))) return STATUS_NO_MEMORY;
adapter->handle = desc->hAdapter;
adapter->vk_device = device;
pthread_mutex_lock(&d3dkmt_mutex);
list_add_head(&x11_d3dkmt_adapters, &adapter->entry);
pthread_mutex_unlock(&d3dkmt_mutex);
return STATUS_SUCCESS;
}
NTSTATUS X11DRV_D3DKMTQueryVideoMemoryInfo( D3DKMT_QUERYVIDEOMEMORYINFO *desc )
{
VkPhysicalDeviceMemoryBudgetPropertiesEXT budget;
VkPhysicalDeviceMemoryProperties2 properties2;
struct x11_d3dkmt_adapter *adapter;
unsigned int i;
desc->Budget = 0;
desc->CurrentUsage = 0;
desc->CurrentReservation = 0;
desc->AvailableForReservation = 0;
if (!d3dkmt_use_vulkan())
{
WARN("Vulkan is unavailable.\n");
return STATUS_UNSUCCESSFUL;
}
pthread_mutex_lock(&d3dkmt_mutex);
if ((adapter = find_adapter_from_handle(desc->hAdapter)))
{
memset(&budget, 0, sizeof(budget));
budget.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
properties2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
properties2.pNext = &budget;
pvkGetPhysicalDeviceMemoryProperties2KHR(adapter->vk_device, &properties2);
for (i = 0; i < properties2.memoryProperties.memoryHeapCount; ++i)
{
if ((desc->MemorySegmentGroup == D3DKMT_MEMORY_SEGMENT_GROUP_LOCAL
&& properties2.memoryProperties.memoryHeaps[i].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
|| (desc->MemorySegmentGroup == D3DKMT_MEMORY_SEGMENT_GROUP_NON_LOCAL
&& !(properties2.memoryProperties.memoryHeaps[i].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)))
{
desc->Budget += budget.heapBudget[i];
desc->CurrentUsage += budget.heapUsage[i];
}
}
desc->AvailableForReservation = desc->Budget / 2;
}
pthread_mutex_unlock(&d3dkmt_mutex);
return adapter ? STATUS_SUCCESS : STATUS_INVALID_PARAMETER;
}
NTSTATUS x11drv_client_func( enum x11drv_client_funcs id, const void *params, ULONG size )
{
void *ret_ptr;

3
dlls/winex11.drv/xrender.c
View file

@ -2234,9 +2234,6 @@ static const struct gdi_dc_funcs xrender_funcs =
NULL, /* pStrokeAndFillPath */
NULL, /* pStrokePath */
NULL, /* pUnrealizePalette */
NULL, /* pD3DKMTCloseAdapter */
NULL, /* pD3DKMTOpenAdapterFromLuid */
NULL, /* pD3DKMTQueryVideoMemoryInfo */
GDI_PRIORITY_GRAPHICS_DRV + 10 /* priority */
};

3
include/wine/gdi_driver.h
View file

@ -166,9 +166,6 @@ struct gdi_dc_funcs
BOOL (*pStrokeAndFillPath)(PHYSDEV);
BOOL (*pStrokePath)(PHYSDEV);
BOOL (*pUnrealizePalette)(HPALETTE);
NTSTATUS (*pD3DKMTCloseAdapter)(const D3DKMT_CLOSEADAPTER *);
NTSTATUS (*pD3DKMTOpenAdapterFromLuid)(D3DKMT_OPENADAPTERFROMLUID *);
NTSTATUS (*pD3DKMTQueryVideoMemoryInfo)(D3DKMT_QUERYVIDEOMEMORYINFO *);
/* priority order for the driver on the stack */
UINT priority;