#include <math.h>
#include <xf86drm.h>
#include <xf86drmMode.h>
-#include <drm_fourcc.h>
+#include "drm-uapi/drm_fourcc.h"
#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
#include <xcb/randr.h>
#include <X11/Xlib-xcb.h>
pthread_cond_t wait_cond;
pthread_t wait_thread;
- struct list_head connectors;
+ struct list_head connectors; /* list of all discovered connectors */
};
#define wsi_for_each_display_mode(_mode, _conn) \
(double) MAX2(wsi->vscan, 1));
}
-static uint64_t wsi_get_current_monotonic(void)
-{
- struct timespec tv;
-
- clock_gettime(CLOCK_MONOTONIC, &tv);
- return tv.tv_nsec + tv.tv_sec*1000000000ull;
-}
-
static uint64_t wsi_rel_to_abs_time(uint64_t rel_time)
{
- uint64_t current_time = wsi_get_current_monotonic();
+ uint64_t current_time = wsi_common_get_current_time();
/* check for overflow */
if (rel_time > UINT64_MAX - current_time)
struct wsi_display_mode *display_mode,
VkDisplayModeProperties2KHR *properties)
{
- assert(properties->sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR);
+ assert(properties->sType == VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR);
VkDisplayModePropertiesKHR *prop = &properties->displayModeProperties;
prop->displayMode = wsi_display_mode_to_handle(display_mode);
const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo,
VkDisplayPlaneCapabilities2KHR *capabilities)
{
- assert(capabilities->sType =
+ assert(capabilities->sType ==
VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR);
- return wsi_get_display_plane_capabilities(physical_device, wsi_device,
- pDisplayPlaneInfo->mode,
- pDisplayPlaneInfo->planeIndex,
- &capabilities->capabilities);
+ VkResult result =
+ wsi_get_display_plane_capabilities(physical_device, wsi_device,
+ pDisplayPlaneInfo->mode,
+ pDisplayPlaneInfo->planeIndex,
+ &capabilities->capabilities);
+
+ vk_foreach_struct(ext, capabilities->pNext) {
+ switch (ext->sType) {
+ case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: {
+ VkSurfaceProtectedCapabilitiesKHR *protected = (void *)ext;
+ protected->supportsProtected = VK_FALSE;
+ break;
+ }
+
+ default:
+ /* Ignored */
+ break;
+ }
+ }
+
+ return result;
}
VkResult
static VkResult
wsi_display_surface_get_support(VkIcdSurfaceBase *surface,
struct wsi_device *wsi_device,
- const VkAllocationCallbacks *allocator,
uint32_t queueFamilyIndex,
- int local_fd,
VkBool32* pSupported)
{
*pSupported = VK_TRUE;
static VkResult
wsi_display_surface_get_capabilities(VkIcdSurfaceBase *surface_base,
+ struct wsi_device *wsi_device,
VkSurfaceCapabilitiesKHR* caps)
{
VkIcdSurfaceDisplay *surface = (VkIcdSurfaceDisplay *) surface_base;
caps->currentExtent.width = mode->hdisplay;
caps->currentExtent.height = mode->vdisplay;
- /* XXX Figure out extents based on driver capabilities */
- caps->maxImageExtent = caps->minImageExtent = caps->currentExtent;
+ caps->minImageExtent = (VkExtent2D) { 1, 1 };
+ caps->maxImageExtent = (VkExtent2D) {
+ wsi_device->maxImageDimension2D,
+ wsi_device->maxImageDimension2D,
+ };
caps->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+ VK_IMAGE_USAGE_STORAGE_BIT |
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
return VK_SUCCESS;
static VkResult
wsi_display_surface_get_capabilities2(VkIcdSurfaceBase *icd_surface,
+ struct wsi_device *wsi_device,
const void *info_next,
VkSurfaceCapabilities2KHR *caps)
{
assert(caps->sType == VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR);
VkResult result;
- result = wsi_display_surface_get_capabilities(icd_surface,
+ result = wsi_display_surface_get_capabilities(icd_surface, wsi_device,
&caps->surfaceCapabilities);
if (result != VK_SUCCESS)
return result;
return vk_outarray_status(&conn);
}
+static VkResult
+wsi_display_surface_get_present_rectangles(VkIcdSurfaceBase *surface_base,
+ struct wsi_device *wsi_device,
+ uint32_t* pRectCount,
+ VkRect2D* pRects)
+{
+ VkIcdSurfaceDisplay *surface = (VkIcdSurfaceDisplay *) surface_base;
+ wsi_display_mode *mode = wsi_display_mode_from_handle(surface->displayMode);
+ VK_OUTARRAY_MAKE(out, pRects, pRectCount);
+
+ if (wsi_device_matches_drm_fd(wsi_device, mode->connector->wsi->fd)) {
+ vk_outarray_append(&out, rect) {
+ *rect = (VkRect2D) {
+ .offset = { 0, 0 },
+ .extent = { mode->hdisplay, mode->vdisplay },
+ };
+ }
+ }
+
+ return vk_outarray_status(&out);
+}
+
static void
wsi_display_destroy_buffer(struct wsi_display *wsi,
uint32_t buffer)
{
- (void) drmIoctl(wsi->fd, DRM_IOCTL_MODE_DESTROY_DUMB,
- &((struct drm_mode_destroy_dumb) { .handle = buffer }));
+ (void) drmIoctl(wsi->fd, DRM_IOCTL_GEM_CLOSE,
+ &((struct drm_gem_close) { .handle = buffer }));
}
static VkResult
for (uint32_t i = 0; i < chain->base.image_count; i++)
wsi_display_image_finish(drv_chain, allocator, &chain->images[i]);
+
+ wsi_swapchain_finish(&chain->base);
vk_free(allocator, chain);
return VK_SUCCESS;
}
static VkResult
wsi_display_acquire_next_image(struct wsi_swapchain *drv_chain,
- uint64_t timeout,
- VkSemaphore semaphore,
+ const VkAcquireNextImageInfoKHR *info,
uint32_t *image_index)
{
struct wsi_display_swapchain *chain =
if (chain->status != VK_SUCCESS)
return chain->status;
+ uint64_t timeout = info->timeout;
if (timeout != 0 && timeout != UINT64_MAX)
timeout = wsi_rel_to_abs_time(timeout);
* which is currently idle.
*/
static uint32_t
-wsi_display_select_crtc(struct wsi_display_connector *connector,
+wsi_display_select_crtc(const struct wsi_display_connector *connector,
drmModeResPtr mode_res,
drmModeConnectorPtr drm_connector)
{
wsi_display_debug("%9lu wait fence %lu %ld\n",
pthread_self(), fence->sequence,
- (int64_t) (timeout - wsi_get_current_monotonic()));
- wsi_display_debug_code(uint64_t start_ns = wsi_get_current_monotonic());
+ (int64_t) (timeout - wsi_common_get_current_time()));
+ wsi_display_debug_code(uint64_t start_ns = wsi_common_get_current_time());
pthread_mutex_lock(&wsi->wait_mutex);
VkResult result;
pthread_mutex_unlock(&wsi->wait_mutex);
wsi_display_debug("%9lu fence wait %f ms\n",
pthread_self(),
- ((int64_t) (wsi_get_current_monotonic() - start_ns)) /
+ ((int64_t) (wsi_common_get_current_time() - start_ns)) /
1.0e6);
return result;
}
flags,
frame_requested,
frame_queued,
- (uint64_t) fence);
+ (uintptr_t) fence);
if (!ret)
return VK_SUCCESS;
VkIcdSurfaceBase *icd_surface,
VkDevice device,
struct wsi_device *wsi_device,
- int local_fd,
const VkSwapchainCreateInfoKHR *create_info,
const VkAllocationCallbacks *allocator,
struct wsi_swapchain **swapchain_out)
VkResult result = wsi_swapchain_init(wsi_device, &chain->base, device,
create_info, allocator);
+ if (result != VK_SUCCESS) {
+ vk_free(allocator, chain);
+ return result;
+ }
chain->base.destroy = wsi_display_swapchain_destroy;
chain->base.get_wsi_image = wsi_display_get_wsi_image;
chain->base.acquire_next_image = wsi_display_acquire_next_image;
chain->base.queue_present = wsi_display_queue_present;
- chain->base.present_mode = create_info->presentMode;
+ chain->base.present_mode = wsi_swapchain_get_present_mode(wsi_device, create_info);
chain->base.image_count = num_images;
chain->wsi = wsi;
return ret;
}
+
+/*
+ * Local version fo the libdrm helper. Added to avoid depending on bleeding
+ * edge version of the library.
+ */
+static int
+local_drmIsMaster(int fd)
+{
+ /* Detect master by attempting something that requires master.
+ *
+ * Authenticating magic tokens requires master and 0 is an
+ * internal kernel detail which we could use. Attempting this on
+ * a master fd would fail therefore fail with EINVAL because 0
+ * is invalid.
+ *
+ * A non-master fd will fail with EACCES, as the kernel checks
+ * for master before attempting to do anything else.
+ *
+ * Since we don't want to leak implementation details, use
+ * EACCES.
+ */
+ return drmAuthMagic(fd, 0) != -EACCES;
+}
+
VkResult
wsi_display_init_wsi(struct wsi_device *wsi_device,
const VkAllocationCallbacks *alloc,
}
wsi->fd = display_fd;
+ if (wsi->fd != -1 && !local_drmIsMaster(wsi->fd))
+ wsi->fd = -1;
+
wsi->alloc = alloc;
list_inithead(&wsi->connectors);
wsi->base.get_formats = wsi_display_surface_get_formats;
wsi->base.get_formats2 = wsi_display_surface_get_formats2;
wsi->base.get_present_modes = wsi_display_surface_get_present_modes;
+ wsi->base.get_present_rectangles = wsi_display_surface_get_present_rectangles;
wsi->base.create_swapchain = wsi_display_surface_create_swapchain;
wsi_device->wsi[VK_ICD_WSI_PLATFORM_DISPLAY] = &wsi->base;
if (!crtc)
return VK_ERROR_INITIALIZATION_FAILED;
+#ifdef HAVE_DRI3_MODIFIERS
xcb_randr_lease_t lease = xcb_generate_id(connection);
xcb_randr_create_lease_cookie_t cl_c =
xcb_randr_create_lease(connection, root, lease, 1, 1,
return VK_ERROR_INITIALIZATION_FAILED;
wsi->fd = fd;
+#endif
return VK_SUCCESS;
}
if (connector)
*display = wsi_display_connector_to_handle(connector);
else
- *display = NULL;
+ *display = VK_NULL_HANDLE;
return VK_SUCCESS;
}
projects / mesa.git / blobdiff