radv_wsi_display.c

/*
 * 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 <amdgpu.h>
#include <fcntl.h>
#include <stdbool.h>
#include <string.h>
#include <unistd.h>
#include <xf86drm.h>
#include <xf86drmMode.h>
#include "drm-uapi/amdgpu_drm.h"
#include "util/debug.h"
#include "util/disk_cache.h"
#include "util/strtod.h"
#include "winsys/amdgpu/radv_amdgpu_winsys_public.h"
#include "radv_cs.h"
#include "radv_private.h"
#include "sid.h"
#include "vk_format.h"
#include "vk_util.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_GetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physical_device,
                                            uint32_t *property_count,
                                            VkDisplayProperties2KHR *properties)
{
   RADV_FROM_HANDLE(radv_physical_device, pdevice, physical_device);

   return wsi_display_get_physical_device_display_properties2(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_GetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physical_device,
                                                 uint32_t *property_count,
                                                 VkDisplayPlaneProperties2KHR *properties)
{
   RADV_FROM_HANDLE(radv_physical_device, pdevice, physical_device);

   return wsi_display_get_physical_device_display_plane_properties2(
      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_GetDisplayModeProperties2KHR(VkPhysicalDevice physical_device, VkDisplayKHR display,
                                  uint32_t *property_count, VkDisplayModeProperties2KHR *properties)
{
   RADV_FROM_HANDLE(radv_physical_device, pdevice, physical_device);

   return wsi_display_get_display_mode_properties2(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_GetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physical_device,
                                     const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo,
                                     VkDisplayPlaneCapabilities2KHR *capabilities)
{
   RADV_FROM_HANDLE(radv_physical_device, pdevice, physical_device);

   return wsi_get_display_plane_capabilities2(physical_device, &pdevice->wsi_device,
                                              pDisplayPlaneInfo, 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->vk.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);
   VkResult ret;
   int fd;

   ret = radv_CreateFence(_device,
                          &(VkFenceCreateInfo){
                             .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
                             .pNext =
                                &(VkExportFenceCreateInfo){
                                   .sType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
                                   .handleTypes = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,
                                },
                          },
                          allocator, _fence);
   if (ret != VK_SUCCESS)
      return ret;

   RADV_FROM_HANDLE(radv_fence, fence, *_fence);

   assert(fence->permanent.kind == RADV_FENCE_SYNCOBJ);

   if (device->ws->export_syncobj(device->ws, fence->permanent.syncobj, &fd)) {
      ret = VK_ERROR_OUT_OF_HOST_MEMORY;
   } else {
      ret = wsi_register_device_event(_device, &device->physical_device->wsi_device,
                                      device_event_info, allocator, NULL, fd);
      close(fd);
   }

   if (ret != VK_SUCCESS)
      radv_DestroyFence(_device, *_fence, allocator);

   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);
   VkResult ret;
   int fd;

   ret = radv_CreateFence(_device,
                          &(VkFenceCreateInfo){
                             .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
                             .pNext =
                                &(VkExportFenceCreateInfo){
                                   .sType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
                                   .handleTypes = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,
                                },
                          },
                          allocator, _fence);
   if (ret != VK_SUCCESS)
      return ret;

   RADV_FROM_HANDLE(radv_fence, fence, *_fence);

   assert(fence->permanent.kind == RADV_FENCE_SYNCOBJ);

   if (device->ws->export_syncobj(device->ws, fence->permanent.syncobj, &fd)) {
      ret = VK_ERROR_OUT_OF_HOST_MEMORY;
   } else {
      ret = wsi_register_display_event(_device, &device->physical_device->wsi_device, display,
                                       display_event_info, allocator, NULL, fd);
      close(fd);
   }

   if (ret != VK_SUCCESS)
      radv_DestroyFence(_device, *_fence, allocator);

   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);
}

VkResult
radv_AcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display)
{
   RADV_FROM_HANDLE(radv_physical_device, pdevice, physicalDevice);

   return wsi_acquire_drm_display(physicalDevice, &pdevice->wsi_device, drmFd, display);
}

VkResult radv_GetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId,
                               VkDisplayKHR* display)
{
   RADV_FROM_HANDLE(radv_physical_device, pdevice, physicalDevice);

   return wsi_get_drm_display(physicalDevice, &pdevice->wsi_device, drmFd, connectorId, display);
}