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) {