X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Famd%2Fvulkan%2Fradv_wsi.c;h=0c9c8593783069556c57ded512e1c59b60d1bf5e;hb=55d8022878fd11093c861a6386734f88454f21b1;hp=51e8ec666f7ea5f4641b084fe99a425656eb0b80;hpb=1e565bc6cea7e82925f066f797b3425cd2e69280;p=mesa.git

diff --git a/src/amd/vulkan/radv_wsi.c b/src/amd/vulkan/radv_wsi.c
index 51e8ec666f7..0c9c8593783 100644
--- a/src/amd/vulkan/radv_wsi.c
+++ b/src/amd/vulkan/radv_wsi.c
@@ -35,13 +35,34 @@ radv_wsi_proc_addr(VkPhysicalDevice physicalDevice, const char *pName)
 	return radv_lookup_entrypoint(pName);
 }
 
+static void
+radv_wsi_set_memory_ownership(VkDevice _device,
+                              VkDeviceMemory _mem,
+                              VkBool32 ownership)
+{
+	RADV_FROM_HANDLE(radv_device, device, _device);
+	RADV_FROM_HANDLE(radv_device_memory, mem, _mem);
+
+	if (ownership)
+		radv_bo_list_add(device, mem->bo);
+	else
+		radv_bo_list_remove(device, mem->bo);
+}
+
 VkResult
 radv_init_wsi(struct radv_physical_device *physical_device)
 {
-	return wsi_device_init(&physical_device->wsi_device,
-			       radv_physical_device_to_handle(physical_device),
-			       radv_wsi_proc_addr,
-			       &physical_device->instance->alloc);
+	VkResult result =  wsi_device_init(&physical_device->wsi_device,
+					   radv_physical_device_to_handle(physical_device),
+					   radv_wsi_proc_addr,
+					   &physical_device->instance->alloc,
+					   physical_device->master_fd,
+					   &physical_device->instance->dri_options);
+	if (result != VK_SUCCESS)
+		return result;
+
+	physical_device->wsi_device.set_memory_ownership = radv_wsi_set_memory_ownership;
+	return VK_SUCCESS;
 }
 
 void
@@ -71,10 +92,8 @@ VkResult radv_GetPhysicalDeviceSurfaceSupportKHR(
 	RADV_FROM_HANDLE(radv_physical_device, device, physicalDevice);
 
 	return wsi_common_get_surface_support(&device->wsi_device,
-					      device->local_fd,
 					      queueFamilyIndex,
 					      surface,
-					      &device->instance->alloc,
 					      pSupported);
 }
 
@@ -102,6 +121,18 @@ VkResult radv_GetPhysicalDeviceSurfaceCapabilities2KHR(
 						    pSurfaceCapabilities);
 }
 
+VkResult radv_GetPhysicalDeviceSurfaceCapabilities2EXT(
+ 	VkPhysicalDevice                            physicalDevice,
+	VkSurfaceKHR                                surface,
+	VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities)
+{
+	RADV_FROM_HANDLE(radv_physical_device, device, physicalDevice);
+
+	return wsi_common_get_surface_capabilities2ext(&device->wsi_device,
+						       surface,
+						       pSurfaceCapabilities);
+}
+
 VkResult radv_GetPhysicalDeviceSurfaceFormatsKHR(
 	VkPhysicalDevice                            physicalDevice,
 	VkSurfaceKHR                                surface,
@@ -155,11 +186,10 @@ VkResult radv_CreateSwapchainKHR(
 	if (pAllocator)
 		alloc = pAllocator;
 	else
-		alloc = &device->alloc;
+		alloc = &device->vk.alloc;
 
 	return wsi_common_create_swapchain(&device->physical_device->wsi_device,
 					   radv_device_to_handle(device),
-					   device->physical_device->local_fd,
 					   pCreateInfo,
 					   alloc,
 					   pSwapchain);
@@ -176,7 +206,7 @@ void radv_DestroySwapchainKHR(
 	if (pAllocator)
 		alloc = pAllocator;
 	else
-		alloc = &device->alloc;
+		alloc = &device->vk.alloc;
 
 	wsi_common_destroy_swapchain(_device, swapchain, alloc);
 }
@@ -193,27 +223,76 @@ VkResult radv_GetSwapchainImagesKHR(
 }
 
 VkResult radv_AcquireNextImageKHR(
-	VkDevice                                     _device,
+	VkDevice                                     device,
 	VkSwapchainKHR                               swapchain,
 	uint64_t                                     timeout,
 	VkSemaphore                                  semaphore,
-	VkFence                                      _fence,
+	VkFence                                      fence,
+	uint32_t*                                    pImageIndex)
+{
+	VkAcquireNextImageInfoKHR acquire_info = {
+		.sType = VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR,
+		.swapchain = swapchain,
+		.timeout = timeout,
+		.semaphore = semaphore,
+		.fence = fence,
+		.deviceMask = 0,
+	};
+
+	return radv_AcquireNextImage2KHR(device, &acquire_info, pImageIndex);
+}
+
+VkResult radv_AcquireNextImage2KHR(
+	VkDevice                                     _device,
+	const VkAcquireNextImageInfoKHR*             pAcquireInfo,
 	uint32_t*                                    pImageIndex)
 {
 	RADV_FROM_HANDLE(radv_device, device, _device);
 	struct radv_physical_device *pdevice = device->physical_device;
-	RADV_FROM_HANDLE(radv_fence, fence, _fence);
-
-	VkResult result = wsi_common_acquire_next_image(&pdevice->wsi_device,
-							_device,
-							swapchain,
-							timeout,
-							semaphore,
-							pImageIndex);
-
-	if (fence && (result == VK_SUCCESS || result == VK_SUBOPTIMAL_KHR)) {
-		fence->submitted = true;
-		fence->signalled = true;
+	RADV_FROM_HANDLE(radv_fence, fence, pAcquireInfo->fence);
+	RADV_FROM_HANDLE(radv_semaphore, semaphore, pAcquireInfo->semaphore);
+
+	VkResult result = wsi_common_acquire_next_image2(&pdevice->wsi_device,
+							 _device,
+                                                         pAcquireInfo,
+							 pImageIndex);
+
+	if (result == VK_SUCCESS || result == VK_SUBOPTIMAL_KHR) {
+		if (fence) {
+			struct radv_fence_part *part =
+				fence->temporary.kind != RADV_FENCE_NONE ?
+				&fence->temporary : &fence->permanent;
+
+			switch (part->kind) {
+			case RADV_FENCE_NONE:
+				break;
+			case RADV_FENCE_WINSYS:
+				device->ws->signal_fence(part->fence);
+				break;
+			case RADV_FENCE_SYNCOBJ:
+				device->ws->signal_syncobj(device->ws, part->syncobj, 0);
+				break;
+			default:
+				unreachable("Invalid WSI fence type");
+			}
+		}
+		if (semaphore) {
+			struct radv_semaphore_part *part =
+				semaphore->temporary.kind != RADV_SEMAPHORE_NONE ?
+					&semaphore->temporary : &semaphore->permanent;
+
+			switch (part->kind) {
+			case RADV_SEMAPHORE_NONE:
+			case RADV_SEMAPHORE_WINSYS:
+				/* Do not need to do anything. */
+				break;
+			case RADV_SEMAPHORE_TIMELINE:
+				unreachable("WSI only allows binary semaphores.");
+			case RADV_SEMAPHORE_SYNCOBJ:
+				device->ws->signal_syncobj(device->ws, part->syncobj, 0);
+				break;
+			}
+		}
 	}
 	return result;
 }
@@ -225,7 +304,43 @@ VkResult radv_QueuePresentKHR(
 	RADV_FROM_HANDLE(radv_queue, queue, _queue);
 	return wsi_common_queue_present(&queue->device->physical_device->wsi_device,
 					radv_device_to_handle(queue->device),
-					_queue,
-					queue->queue_family_index,
-					pPresentInfo);
+				        _queue,
+				        queue->queue_family_index,
+				        pPresentInfo);
+}
+
+
+VkResult radv_GetDeviceGroupPresentCapabilitiesKHR(
+    VkDevice                                    device,
+    VkDeviceGroupPresentCapabilitiesKHR*        pCapabilities)
+{
+   memset(pCapabilities->presentMask, 0,
+          sizeof(pCapabilities->presentMask));
+   pCapabilities->presentMask[0] = 0x1;
+   pCapabilities->modes = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
+
+   return VK_SUCCESS;
+}
+
+VkResult radv_GetDeviceGroupSurfacePresentModesKHR(
+    VkDevice                                    device,
+    VkSurfaceKHR                                surface,
+    VkDeviceGroupPresentModeFlagsKHR*           pModes)
+{
+   *pModes = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
+
+   return VK_SUCCESS;
+}
+
+VkResult radv_GetPhysicalDevicePresentRectanglesKHR(
+	VkPhysicalDevice                            physicalDevice,
+	VkSurfaceKHR                                surface,
+	uint32_t*                                   pRectCount,
+	VkRect2D*                                   pRects)
+{
+	RADV_FROM_HANDLE(radv_physical_device, device, physicalDevice);
+
+	return wsi_common_get_present_rectangles(&device->wsi_device,
+						 surface,
+						 pRectCount, pRects);
 }