From: Jonathan Marek Date: Wed, 13 Nov 2019 21:50:36 +0000 (-0500) Subject: turnip: add display wsi X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=df9f2adfa3290ab04fc887af8f7f51cddcaabc3b;p=mesa.git turnip: add display wsi Copied from radv (minus the fence change) Signed-off-by: Jonathan Marek Reviewed-by: Eric Anholt --- diff --git a/src/freedreno/vulkan/meson.build b/src/freedreno/vulkan/meson.build index 70efd26008b..e57a24c00c9 100644 --- a/src/freedreno/vulkan/meson.build +++ b/src/freedreno/vulkan/meson.build @@ -87,6 +87,11 @@ if with_platform_wayland libtu_files += files('tu_wsi_wayland.c') endif +if with_platform_drm + tu_flags += '-DVK_USE_PLATFORM_DISPLAY_KHR' + libtu_files += files('tu_wsi_display.c') +endif + libvulkan_freedreno = shared_library( 'vulkan_freedreno', [libtu_files, tu_entrypoints, tu_extensions_c, tu_format_table_c, freedreno_xml_header_files], diff --git a/src/freedreno/vulkan/tu_fence.c b/src/freedreno/vulkan/tu_fence.c index 793f0ab3cd0..68c1f31c0b8 100644 --- a/src/freedreno/vulkan/tu_fence.c +++ b/src/freedreno/vulkan/tu_fence.c @@ -86,6 +86,7 @@ tu_fence_init(struct tu_fence *fence, bool signaled) { fence->signaled = signaled; fence->fd = -1; + fence->fence_wsi = NULL; } void @@ -93,6 +94,8 @@ tu_fence_finish(struct tu_fence *fence) { if (fence->fd >= 0) close(fence->fd); + if (fence->fence_wsi) + fence->fence_wsi->destroy(fence->fence_wsi); } /** @@ -349,6 +352,15 @@ tu_WaitForFences(VkDevice _device, if (fds != stack_fds) vk_free(&device->alloc, fds); + for (uint32_t i = 0; i < fenceCount; ++i) { + TU_FROM_HANDLE(tu_fence, fence, pFences[i]); + if (fence->fence_wsi) { + VkResult result = fence->fence_wsi->wait(fence->fence_wsi, timeout); + if (result != VK_SUCCESS) + return result; + } + } + return result; } @@ -376,6 +388,15 @@ tu_GetFenceStatus(VkDevice _device, VkFence _fence) else if (err && errno != ETIME) return VK_ERROR_OUT_OF_HOST_MEMORY; } + if (fence->fence_wsi) { + VkResult result = fence->fence_wsi->wait(fence->fence_wsi, 0); + + if (result != VK_SUCCESS) { + if (result == VK_TIMEOUT) + return VK_NOT_READY; + return result; + } + } return fence->signaled ? VK_SUCCESS : VK_NOT_READY; } diff --git a/src/freedreno/vulkan/tu_private.h b/src/freedreno/vulkan/tu_private.h index c24e7d3f6ce..ef306c92aea 100644 --- a/src/freedreno/vulkan/tu_private.h +++ b/src/freedreno/vulkan/tu_private.h @@ -419,6 +419,7 @@ struct tu_meta_state struct tu_fence { + struct wsi_fence *fence_wsi; bool signaled; int fd; }; diff --git a/src/freedreno/vulkan/tu_wsi_display.c b/src/freedreno/vulkan/tu_wsi_display.c new file mode 100644 index 00000000000..9a9696d93cc --- /dev/null +++ b/src/freedreno/vulkan/tu_wsi_display.c @@ -0,0 +1,339 @@ +/* + * Copyright © 2017 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting documentation, and + * that the name of the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ + +#include +#include +#include +#include +#include "tu_private.h" +#include "tu_cs.h" +#include "util/disk_cache.h" +#include "util/strtod.h" +#include "vk_util.h" +#include +#include +#include "vk_format.h" +#include "util/debug.h" +#include "wsi_common_display.h" + +VkResult +tu_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physical_device, + uint32_t *property_count, + VkDisplayPropertiesKHR *properties) +{ + TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device); + + return wsi_display_get_physical_device_display_properties( + physical_device, + &pdevice->wsi_device, + property_count, + properties); +} + +VkResult +tu_GetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physical_device, + uint32_t *property_count, + VkDisplayProperties2KHR *properties) +{ + TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device); + + return wsi_display_get_physical_device_display_properties2( + physical_device, + &pdevice->wsi_device, + property_count, + properties); +} + +VkResult +tu_GetPhysicalDeviceDisplayPlanePropertiesKHR( + VkPhysicalDevice physical_device, + uint32_t *property_count, + VkDisplayPlanePropertiesKHR *properties) +{ + TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device); + + return wsi_display_get_physical_device_display_plane_properties( + physical_device, + &pdevice->wsi_device, + property_count, + properties); +} + +VkResult +tu_GetPhysicalDeviceDisplayPlaneProperties2KHR( + VkPhysicalDevice physical_device, + uint32_t *property_count, + VkDisplayPlaneProperties2KHR *properties) +{ + TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device); + + return wsi_display_get_physical_device_display_plane_properties2( + physical_device, + &pdevice->wsi_device, + property_count, + properties); +} + +VkResult +tu_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physical_device, + uint32_t plane_index, + uint32_t *display_count, + VkDisplayKHR *displays) +{ + TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device); + + return wsi_display_get_display_plane_supported_displays( + physical_device, + &pdevice->wsi_device, + plane_index, + display_count, + displays); +} + + +VkResult +tu_GetDisplayModePropertiesKHR(VkPhysicalDevice physical_device, + VkDisplayKHR display, + uint32_t *property_count, + VkDisplayModePropertiesKHR *properties) +{ + TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device); + + return wsi_display_get_display_mode_properties(physical_device, + &pdevice->wsi_device, + display, + property_count, + properties); +} + +VkResult +tu_GetDisplayModeProperties2KHR(VkPhysicalDevice physical_device, + VkDisplayKHR display, + uint32_t *property_count, + VkDisplayModeProperties2KHR *properties) +{ + TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device); + + return wsi_display_get_display_mode_properties2(physical_device, + &pdevice->wsi_device, + display, + property_count, + properties); +} + +VkResult +tu_CreateDisplayModeKHR(VkPhysicalDevice physical_device, + VkDisplayKHR display, + const VkDisplayModeCreateInfoKHR *create_info, + const VkAllocationCallbacks *allocator, + VkDisplayModeKHR *mode) +{ + TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device); + + return wsi_display_create_display_mode(physical_device, + &pdevice->wsi_device, + display, + create_info, + allocator, + mode); +} + +VkResult +tu_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physical_device, + VkDisplayModeKHR mode_khr, + uint32_t plane_index, + VkDisplayPlaneCapabilitiesKHR *capabilities) +{ + TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device); + + return wsi_get_display_plane_capabilities(physical_device, + &pdevice->wsi_device, + mode_khr, + plane_index, + capabilities); +} + +VkResult +tu_GetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physical_device, + const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo, + VkDisplayPlaneCapabilities2KHR *capabilities) +{ + TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device); + + return wsi_get_display_plane_capabilities2(physical_device, + &pdevice->wsi_device, + pDisplayPlaneInfo, + capabilities); +} + +VkResult +tu_CreateDisplayPlaneSurfaceKHR( + VkInstance _instance, + const VkDisplaySurfaceCreateInfoKHR *create_info, + const VkAllocationCallbacks *allocator, + VkSurfaceKHR *surface) +{ + TU_FROM_HANDLE(tu_instance, instance, _instance); + const VkAllocationCallbacks *alloc; + + if (allocator) + alloc = allocator; + else + alloc = &instance->alloc; + + return wsi_create_display_surface(_instance, alloc, + create_info, surface); +} + +VkResult +tu_ReleaseDisplayEXT(VkPhysicalDevice physical_device, + VkDisplayKHR display) +{ + TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device); + + return wsi_release_display(physical_device, + &pdevice->wsi_device, + display); +} + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT +VkResult +tu_AcquireXlibDisplayEXT(VkPhysicalDevice physical_device, + Display *dpy, + VkDisplayKHR display) +{ + TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device); + + return wsi_acquire_xlib_display(physical_device, + &pdevice->wsi_device, + dpy, + display); +} + +VkResult +tu_GetRandROutputDisplayEXT(VkPhysicalDevice physical_device, + Display *dpy, + RROutput output, + VkDisplayKHR *display) +{ + TU_FROM_HANDLE(tu_physical_device, pdevice, physical_device); + + return wsi_get_randr_output_display(physical_device, + &pdevice->wsi_device, + dpy, + output, + display); +} +#endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */ + +/* VK_EXT_display_control */ + +VkResult +tu_DisplayPowerControlEXT(VkDevice _device, + VkDisplayKHR display, + const VkDisplayPowerInfoEXT *display_power_info) +{ + TU_FROM_HANDLE(tu_device, device, _device); + + return wsi_display_power_control(_device, + &device->physical_device->wsi_device, + display, + display_power_info); +} + +VkResult +tu_RegisterDeviceEventEXT(VkDevice _device, + const VkDeviceEventInfoEXT *device_event_info, + const VkAllocationCallbacks *allocator, + VkFence *_fence) +{ + TU_FROM_HANDLE(tu_device, device, _device); + struct tu_fence *fence; + VkResult ret; + + fence = vk_alloc2(&device->instance->alloc, allocator, sizeof (*fence), + 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); + if (!fence) + return VK_ERROR_OUT_OF_HOST_MEMORY; + + tu_fence_init(fence, false); + + ret = wsi_register_device_event(_device, + &device->physical_device->wsi_device, + device_event_info, + allocator, + &fence->fence_wsi); + if (ret == VK_SUCCESS) + *_fence = tu_fence_to_handle(fence); + else + vk_free2(&device->instance->alloc, allocator, fence); + return ret; +} + +VkResult +tu_RegisterDisplayEventEXT(VkDevice _device, + VkDisplayKHR display, + const VkDisplayEventInfoEXT *display_event_info, + const VkAllocationCallbacks *allocator, + VkFence *_fence) +{ + TU_FROM_HANDLE(tu_device, device, _device); + + struct tu_fence *fence; + VkResult ret; + + fence = vk_alloc2(&device->instance->alloc, allocator, sizeof (*fence), + 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); + if (!fence) + return VK_ERROR_OUT_OF_HOST_MEMORY; + + tu_fence_init(fence, false); + + ret = wsi_register_display_event(_device, + &device->physical_device->wsi_device, + display, + display_event_info, + allocator, + &fence->fence_wsi); + + if (ret == VK_SUCCESS) + *_fence = tu_fence_to_handle(fence); + else + vk_free2(&device->instance->alloc, allocator, fence); + return ret; +} + +VkResult +tu_GetSwapchainCounterEXT(VkDevice _device, + VkSwapchainKHR swapchain, + VkSurfaceCounterFlagBitsEXT flag_bits, + uint64_t *value) +{ + TU_FROM_HANDLE(tu_device, device, _device); + + return wsi_get_swapchain_counter(_device, + &device->physical_device->wsi_device, + swapchain, + flag_bits, + value); +} +