/* * 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 "radv_private.h" #include "radv_cs.h" #include "util/disk_cache.h" #include "util/strtod.h" #include "vk_util.h" #include #include #include #include #include "winsys/amdgpu/radv_amdgpu_winsys_public.h" #include "ac_llvm_util.h" #include "vk_format.h" #include "sid.h" #include "util/debug.h" #include "wsi_common_display.h" #define MM_PER_PIXEL (1.0/96.0 * 25.4) VkResult radv_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physical_device, uint32_t *property_count, VkDisplayPropertiesKHR *properties) { RADV_FROM_HANDLE(radv_physical_device, pdevice, physical_device); return wsi_display_get_physical_device_display_properties( physical_device, &pdevice->wsi_device, property_count, properties); } VkResult radv_GetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physical_device, uint32_t *property_count, VkDisplayPlanePropertiesKHR *properties) { RADV_FROM_HANDLE(radv_physical_device, pdevice, physical_device); return wsi_display_get_physical_device_display_plane_properties( physical_device, &pdevice->wsi_device, property_count, properties); } VkResult radv_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physical_device, uint32_t plane_index, uint32_t *display_count, VkDisplayKHR *displays) { RADV_FROM_HANDLE(radv_physical_device, pdevice, physical_device); return wsi_display_get_display_plane_supported_displays( physical_device, &pdevice->wsi_device, plane_index, display_count, displays); } VkResult radv_GetDisplayModePropertiesKHR(VkPhysicalDevice physical_device, VkDisplayKHR display, uint32_t *property_count, VkDisplayModePropertiesKHR *properties) { RADV_FROM_HANDLE(radv_physical_device, pdevice, physical_device); return wsi_display_get_display_mode_properties(physical_device, &pdevice->wsi_device, display, property_count, properties); } VkResult radv_CreateDisplayModeKHR(VkPhysicalDevice physical_device, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR *create_info, const VkAllocationCallbacks *allocator, VkDisplayModeKHR *mode) { RADV_FROM_HANDLE(radv_physical_device, pdevice, physical_device); return wsi_display_create_display_mode(physical_device, &pdevice->wsi_device, display, create_info, allocator, mode); } VkResult radv_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physical_device, VkDisplayModeKHR mode_khr, uint32_t plane_index, VkDisplayPlaneCapabilitiesKHR *capabilities) { RADV_FROM_HANDLE(radv_physical_device, pdevice, physical_device); return wsi_get_display_plane_capabilities(physical_device, &pdevice->wsi_device, mode_khr, plane_index, capabilities); } VkResult radv_CreateDisplayPlaneSurfaceKHR( VkInstance _instance, const VkDisplaySurfaceCreateInfoKHR *create_info, const VkAllocationCallbacks *allocator, VkSurfaceKHR *surface) { RADV_FROM_HANDLE(radv_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 radv_ReleaseDisplayEXT(VkPhysicalDevice physical_device, VkDisplayKHR display) { RADV_FROM_HANDLE(radv_physical_device, pdevice, physical_device); return wsi_release_display(physical_device, &pdevice->wsi_device, display); } #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT VkResult radv_AcquireXlibDisplayEXT(VkPhysicalDevice physical_device, Display *dpy, VkDisplayKHR display) { RADV_FROM_HANDLE(radv_physical_device, pdevice, physical_device); return wsi_acquire_xlib_display(physical_device, &pdevice->wsi_device, dpy, display); } VkResult radv_GetRandROutputDisplayEXT(VkPhysicalDevice physical_device, Display *dpy, RROutput output, VkDisplayKHR *display) { RADV_FROM_HANDLE(radv_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 radv_DisplayPowerControlEXT(VkDevice _device, VkDisplayKHR display, const VkDisplayPowerInfoEXT *display_power_info) { RADV_FROM_HANDLE(radv_device, device, _device); return wsi_display_power_control(_device, &device->physical_device->wsi_device, display, display_power_info); } VkResult radv_RegisterDeviceEventEXT(VkDevice _device, const VkDeviceEventInfoEXT *device_event_info, const VkAllocationCallbacks *allocator, VkFence *_fence) { RADV_FROM_HANDLE(radv_device, device, _device); struct radv_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; fence->fence = NULL; fence->submitted = true; fence->signalled = false; fence->syncobj = 0; fence->temp_syncobj = 0; ret = wsi_register_device_event(_device, &device->physical_device->wsi_device, device_event_info, allocator, &fence->fence_wsi); if (ret == VK_SUCCESS) *_fence = radv_fence_to_handle(fence); else vk_free2(&device->instance->alloc, allocator, fence); return ret; } VkResult radv_RegisterDisplayEventEXT(VkDevice _device, VkDisplayKHR display, const VkDisplayEventInfoEXT *display_event_info, const VkAllocationCallbacks *allocator, VkFence *_fence) { RADV_FROM_HANDLE(radv_device, device, _device); struct radv_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; fence->fence = NULL; fence->submitted = true; fence->signalled = false; fence->syncobj = 0; fence->temp_syncobj = 0; ret = wsi_register_display_event(_device, &device->physical_device->wsi_device, display, display_event_info, allocator, &(fence->fence_wsi)); if (ret == VK_SUCCESS) *_fence = radv_fence_to_handle(fence); else vk_free2(&device->instance->alloc, allocator, fence); return ret; } VkResult radv_GetSwapchainCounterEXT(VkDevice _device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT flag_bits, uint64_t *value) { RADV_FROM_HANDLE(radv_device, device, _device); return wsi_get_swapchain_counter(_device, &device->physical_device->wsi_device, swapchain, flag_bits, value); }