radv: port to common wsi codebase

This drops all the radv WSI code in favour of using
the new shared code that was ported from anv

This regresses Talos for now, Jason has pointed out
the bug is in Talos and we should wait for them to fix it.

Reviewed-by: Jason Ekstrand <[email protected]>

1 files changed, 149 insertions, 27 deletions

diff --git a/src/amd/vulkan/radv_wsi.c b/src/amd/vulkan/radv_wsi.c
index 1a0171d8c9f..ba5c37ba268 100644
--- a/src/amd/vulkan/radv_wsi.c
+++ b/src/amd/vulkan/radv_wsi.c
@@ -23,27 +23,33 @@
  * IN THE SOFTWARE.
  */
 
-#include "radv_wsi.h"
+#include "radv_private.h"
+#include "wsi_common.h"
 
+static const struct wsi_callbacks wsi_cbs = {
+   .get_phys_device_format_properties = radv_GetPhysicalDeviceFormatProperties,
+};
 
 VkResult
 radv_init_wsi(struct radv_physical_device *physical_device)
 {
 	VkResult result;
 
-	memset(physical_device->wsi, 0, sizeof(physical_device->wsi));
+	memset(physical_device->wsi_device.wsi, 0, sizeof(physical_device->wsi_device.wsi));
 
 #ifdef VK_USE_PLATFORM_XCB_KHR
-	result = radv_x11_init_wsi(physical_device);
+	result = wsi_x11_init_wsi(&physical_device->wsi_device, &physical_device->instance->alloc);
 	if (result != VK_SUCCESS)
 		return result;
 #endif
 
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
-	result = radv_wl_init_wsi(physical_device);
+	result = wsi_wl_init_wsi(&physical_device->wsi_device, &physical_device->instance->alloc,
+				 radv_physical_device_to_handle(physical_device),
+				 &wsi_cbs);
 	if (result != VK_SUCCESS) {
 #ifdef VK_USE_PLATFORM_XCB_KHR
-		radv_x11_finish_wsi(physical_device);
+		wsi_x11_finish_wsi(&physical_device->wsi_device, &physical_device->instance->alloc);
 #endif
 		return result;
 	}
@@ -56,10 +62,10 @@ void
 radv_finish_wsi(struct radv_physical_device *physical_device)
 {
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
-	radv_wl_finish_wsi(physical_device);
+	wsi_wl_finish_wsi(&physical_device->wsi_device, &physical_device->instance->alloc);
 #endif
 #ifdef VK_USE_PLATFORM_XCB_KHR
-	radv_x11_finish_wsi(physical_device);
+	wsi_x11_finish_wsi(&physical_device->wsi_device, &physical_device->instance->alloc);
 #endif
 }
 
@@ -82,9 +88,11 @@ VkResult radv_GetPhysicalDeviceSurfaceSupportKHR(
 {
 	RADV_FROM_HANDLE(radv_physical_device, device, physicalDevice);
 	RADV_FROM_HANDLE(_VkIcdSurfaceBase, surface, _surface);
-	struct radv_wsi_interface *iface = device->wsi[surface->platform];
+	struct wsi_interface *iface = device->wsi_device.wsi[surface->platform];
 
-	return iface->get_support(surface, device, queueFamilyIndex, pSupported);
+	return iface->get_support(surface, &device->wsi_device,
+				  &device->instance->alloc,
+				  queueFamilyIndex, pSupported);
 }
 
 VkResult radv_GetPhysicalDeviceSurfaceCapabilitiesKHR(
@@ -94,9 +102,9 @@ VkResult radv_GetPhysicalDeviceSurfaceCapabilitiesKHR(
 {
 	RADV_FROM_HANDLE(radv_physical_device, device, physicalDevice);
 	RADV_FROM_HANDLE(_VkIcdSurfaceBase, surface, _surface);
-	struct radv_wsi_interface *iface = device->wsi[surface->platform];
+	struct wsi_interface *iface = device->wsi_device.wsi[surface->platform];
 
-	return iface->get_capabilities(surface, device, pSurfaceCapabilities);
+	return iface->get_capabilities(surface, pSurfaceCapabilities);
 }
 
 VkResult radv_GetPhysicalDeviceSurfaceFormatsKHR(
@@ -107,9 +115,9 @@ VkResult radv_GetPhysicalDeviceSurfaceFormatsKHR(
 {
 	RADV_FROM_HANDLE(radv_physical_device, device, physicalDevice);
 	RADV_FROM_HANDLE(_VkIcdSurfaceBase, surface, _surface);
-	struct radv_wsi_interface *iface = device->wsi[surface->platform];
+	struct wsi_interface *iface = device->wsi_device.wsi[surface->platform];
 
-	return iface->get_formats(surface, device, pSurfaceFormatCount,
+	return iface->get_formats(surface, &device->wsi_device, pSurfaceFormatCount,
 				  pSurfaceFormats);
 }
 
@@ -121,12 +129,119 @@ VkResult radv_GetPhysicalDeviceSurfacePresentModesKHR(
 {
 	RADV_FROM_HANDLE(radv_physical_device, device, physicalDevice);
 	RADV_FROM_HANDLE(_VkIcdSurfaceBase, surface, _surface);
-	struct radv_wsi_interface *iface = device->wsi[surface->platform];
+	struct wsi_interface *iface = device->wsi_device.wsi[surface->platform];
 
-	return iface->get_present_modes(surface, device, pPresentModeCount,
+	return iface->get_present_modes(surface, pPresentModeCount,
 					pPresentModes);
 }
 
+static VkResult
+radv_wsi_image_create(VkDevice device_h,
+		      const VkSwapchainCreateInfoKHR *pCreateInfo,
+		      const VkAllocationCallbacks* pAllocator,
+		      VkImage *image_p,
+		      VkDeviceMemory *memory_p,
+		      uint32_t *size,
+		      uint32_t *offset,
+		      uint32_t *row_pitch, int *fd_p)
+{
+	struct radv_device *device = radv_device_from_handle(device_h);
+	VkResult result = VK_SUCCESS;
+	struct radeon_surf *surface;
+	VkImage image_h;
+	struct radv_image *image;
+	bool bret;
+	int fd;
+
+	result = radv_image_create(device_h,
+				   &(struct radv_image_create_info) {
+					   .vk_info =
+						   &(VkImageCreateInfo) {
+						   .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
+						   .imageType = VK_IMAGE_TYPE_2D,
+						   .format = pCreateInfo->imageFormat,
+						   .extent = {
+							   .width = pCreateInfo->imageExtent.width,
+							   .height = pCreateInfo->imageExtent.height,
+							   .depth = 1
+						   },
+						   .mipLevels = 1,
+						   .arrayLayers = 1,
+						   .samples = 1,
+						   /* FIXME: Need a way to use X tiling to allow scanout */
+						   .tiling = VK_IMAGE_TILING_OPTIMAL,
+						   .usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+						   .flags = 0,
+					   },
+						   .scanout = true},
+				   NULL,
+				   &image_h);
+	if (result != VK_SUCCESS)
+		return result;
+
+	image = radv_image_from_handle(image_h);
+
+	VkDeviceMemory memory_h;
+	struct radv_device_memory *memory;
+	result = radv_AllocateMemory(device_h,
+				     &(VkMemoryAllocateInfo) {
+					     .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+						     .allocationSize = image->size,
+						     .memoryTypeIndex = 0,
+						     },
+				     NULL /* XXX: pAllocator */,
+				     &memory_h);
+	if (result != VK_SUCCESS)
+		goto fail_create_image;
+
+	memory = radv_device_memory_from_handle(memory_h);
+
+	radv_BindImageMemory(VK_NULL_HANDLE, image_h, memory_h, 0);
+
+	bret = device->ws->buffer_get_fd(device->ws,
+					 memory->bo, &fd);
+	if (bret == false)
+		goto fail_alloc_memory;
+
+	{
+		struct radeon_bo_metadata metadata;
+		radv_init_metadata(device, image, &metadata);
+		device->ws->buffer_set_metadata(memory->bo, &metadata);
+	}
+	surface = &image->surface;
+
+	*image_p = image_h;
+	*memory_p = memory_h;
+	*fd_p = fd;
+	*size = image->size;
+	*offset = image->offset;
+	*row_pitch = surface->level[0].pitch_bytes;
+	return VK_SUCCESS;
+ fail_alloc_memory:
+	radv_FreeMemory(device_h, memory_h, pAllocator);
+
+fail_create_image:
+	radv_DestroyImage(device_h, image_h, pAllocator);
+
+	return result;
+}
+
+static void
+radv_wsi_image_free(VkDevice device,
+		    const VkAllocationCallbacks* pAllocator,
+		    VkImage image_h,
+		    VkDeviceMemory memory_h)
+{
+	radv_DestroyImage(device, image_h, pAllocator);
+
+	radv_FreeMemory(device, memory_h, pAllocator);
+}
+
+static const struct wsi_image_fns radv_wsi_image_fns = {
+   .create_wsi_image = radv_wsi_image_create,
+   .free_wsi_image = radv_wsi_image_free,
+};
+
 VkResult radv_CreateSwapchainKHR(
 	VkDevice                                     _device,
 	const VkSwapchainCreateInfoKHR*              pCreateInfo,
@@ -135,12 +250,19 @@ VkResult radv_CreateSwapchainKHR(
 {
 	RADV_FROM_HANDLE(radv_device, device, _device);
 	RADV_FROM_HANDLE(_VkIcdSurfaceBase, surface, pCreateInfo->surface);
-	struct radv_wsi_interface *iface =
-		device->instance->physicalDevice.wsi[surface->platform];
-	struct radv_swapchain *swapchain;
-
-	VkResult result = iface->create_swapchain(surface, device, pCreateInfo,
-						  pAllocator, &swapchain);
+	struct wsi_interface *iface =
+		device->instance->physicalDevice.wsi_device.wsi[surface->platform];
+	struct wsi_swapchain *swapchain;
+	const VkAllocationCallbacks *alloc;
+	if (pAllocator)
+		alloc = pAllocator;
+	else
+		alloc = &device->alloc;
+	VkResult result = iface->create_swapchain(surface, _device,
+						  &device->instance->physicalDevice.wsi_device,
+						  pCreateInfo,
+						  alloc, &radv_wsi_image_fns,
+						  &swapchain);
 	if (result != VK_SUCCESS)
 		return result;
 
@@ -152,7 +274,7 @@ VkResult radv_CreateSwapchainKHR(
 	for (unsigned i = 0; i < ARRAY_SIZE(swapchain->fences); i++)
 		swapchain->fences[i] = VK_NULL_HANDLE;
 
-	*pSwapchain = radv_swapchain_to_handle(swapchain);
+	*pSwapchain = wsi_swapchain_to_handle(swapchain);
 
 	return VK_SUCCESS;
 }
@@ -162,7 +284,7 @@ void radv_DestroySwapchainKHR(
 	VkSwapchainKHR                               _swapchain,
 	const VkAllocationCallbacks*                 pAllocator)
 {
-	RADV_FROM_HANDLE(radv_swapchain, swapchain, _swapchain);
+	RADV_FROM_HANDLE(wsi_swapchain, swapchain, _swapchain);
 
 	for (unsigned i = 0; i < ARRAY_SIZE(swapchain->fences); i++) {
 		if (swapchain->fences[i] != VK_NULL_HANDLE)
@@ -178,7 +300,7 @@ VkResult radv_GetSwapchainImagesKHR(
 	uint32_t*                                    pSwapchainImageCount,
 	VkImage*                                     pSwapchainImages)
 {
-	RADV_FROM_HANDLE(radv_swapchain, swapchain, _swapchain);
+	RADV_FROM_HANDLE(wsi_swapchain, swapchain, _swapchain);
 
 	return swapchain->get_images(swapchain, pSwapchainImageCount,
 				     pSwapchainImages);
@@ -192,7 +314,7 @@ VkResult radv_AcquireNextImageKHR(
 	VkFence                                      fence,
 	uint32_t*                                    pImageIndex)
 {
-	RADV_FROM_HANDLE(radv_swapchain, swapchain, _swapchain);
+	RADV_FROM_HANDLE(wsi_swapchain, swapchain, _swapchain);
 
 	return swapchain->acquire_next_image(swapchain, timeout, semaphore,
 					     pImageIndex);
@@ -206,9 +328,9 @@ VkResult radv_QueuePresentKHR(
 	VkResult result = VK_SUCCESS;
 
 	for (uint32_t i = 0; i < pPresentInfo->swapchainCount; i++) {
-		RADV_FROM_HANDLE(radv_swapchain, swapchain, pPresentInfo->pSwapchains[i]);
+		RADV_FROM_HANDLE(wsi_swapchain, swapchain, pPresentInfo->pSwapchains[i]);
 
-		assert(swapchain->device == queue->device);
+		assert(radv_device_from_handle(swapchain->device) == queue->device);
 		if (swapchain->fences[0] == VK_NULL_HANDLE) {
 			result = radv_CreateFence(radv_device_to_handle(queue->device),
 						  &(VkFenceCreateInfo) {