mirror of
https://gitlab.freedesktop.org/wayland/weston
synced 2024-09-06 18:05:39 +00:00
![Marius Vlad](/assets/img/avatar_default.png)
Until kernel mainline does merge the aysnc page flip ioctl, make the
whole bit look like it's unsupported. We can further switch it back when
it lands into the kernel.
Fixes: 9203d98f
Signed-off-by: Marius Vlad <marius.vlad@collabora.com>
Reported-by: Simon Ser <contact@emersion.fr>
1877 lines
55 KiB
C
1877 lines
55 KiB
C
/*
|
|
* Copyright © 2008-2011 Kristian Høgsberg
|
|
* Copyright © 2011 Intel Corporation
|
|
* Copyright © 2017, 2018 Collabora, Ltd.
|
|
* Copyright © 2017, 2018 General Electric Company
|
|
* Copyright (c) 2018 DisplayLink (UK) Ltd.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the
|
|
* next paragraph) shall be included in all copies or substantial
|
|
* portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <xf86drm.h>
|
|
#include <xf86drmMode.h>
|
|
|
|
#include <libweston/libweston.h>
|
|
#include <libweston/backend-drm.h>
|
|
#include "shared/helpers.h"
|
|
#include "shared/weston-drm-fourcc.h"
|
|
#include "drm-internal.h"
|
|
#include "pixel-formats.h"
|
|
#include "presentation-time-server-protocol.h"
|
|
|
|
struct drm_property_enum_info plane_type_enums[] = {
|
|
[WDRM_PLANE_TYPE_PRIMARY] = {
|
|
.name = "Primary",
|
|
},
|
|
[WDRM_PLANE_TYPE_OVERLAY] = {
|
|
.name = "Overlay",
|
|
},
|
|
[WDRM_PLANE_TYPE_CURSOR] = {
|
|
.name = "Cursor",
|
|
},
|
|
};
|
|
|
|
struct drm_property_enum_info plane_rotation_enums[] = {
|
|
[WDRM_PLANE_ROTATION_0] = {
|
|
.name = "rotate-0",
|
|
},
|
|
[WDRM_PLANE_ROTATION_90] = {
|
|
.name = "rotate-90",
|
|
},
|
|
[WDRM_PLANE_ROTATION_180] = {
|
|
.name = "rotate-180",
|
|
},
|
|
[WDRM_PLANE_ROTATION_270] = {
|
|
.name = "rotate-270",
|
|
},
|
|
[WDRM_PLANE_ROTATION_REFLECT_X] = {
|
|
.name = "reflect-x",
|
|
},
|
|
[WDRM_PLANE_ROTATION_REFLECT_Y] = {
|
|
.name = "reflect-y",
|
|
},
|
|
};
|
|
|
|
const struct drm_property_info plane_props[] = {
|
|
[WDRM_PLANE_TYPE] = {
|
|
.name = "type",
|
|
.enum_values = plane_type_enums,
|
|
.num_enum_values = WDRM_PLANE_TYPE__COUNT,
|
|
},
|
|
[WDRM_PLANE_SRC_X] = { .name = "SRC_X", },
|
|
[WDRM_PLANE_SRC_Y] = { .name = "SRC_Y", },
|
|
[WDRM_PLANE_SRC_W] = { .name = "SRC_W", },
|
|
[WDRM_PLANE_SRC_H] = { .name = "SRC_H", },
|
|
[WDRM_PLANE_CRTC_X] = { .name = "CRTC_X", },
|
|
[WDRM_PLANE_CRTC_Y] = { .name = "CRTC_Y", },
|
|
[WDRM_PLANE_CRTC_W] = { .name = "CRTC_W", },
|
|
[WDRM_PLANE_CRTC_H] = { .name = "CRTC_H", },
|
|
[WDRM_PLANE_FB_ID] = { .name = "FB_ID", },
|
|
[WDRM_PLANE_CRTC_ID] = { .name = "CRTC_ID", },
|
|
[WDRM_PLANE_IN_FORMATS] = { .name = "IN_FORMATS" },
|
|
[WDRM_PLANE_IN_FENCE_FD] = { .name = "IN_FENCE_FD" },
|
|
[WDRM_PLANE_FB_DAMAGE_CLIPS] = { .name = "FB_DAMAGE_CLIPS" },
|
|
[WDRM_PLANE_ZPOS] = { .name = "zpos" },
|
|
[WDRM_PLANE_ROTATION] = {
|
|
.name = "rotation",
|
|
.enum_values = plane_rotation_enums,
|
|
.num_enum_values = WDRM_PLANE_ROTATION__COUNT,
|
|
},
|
|
[WDRM_PLANE_ALPHA] = { .name = "alpha" },
|
|
};
|
|
|
|
struct drm_property_enum_info dpms_state_enums[] = {
|
|
[WDRM_DPMS_STATE_OFF] = {
|
|
.name = "Off",
|
|
},
|
|
[WDRM_DPMS_STATE_ON] = {
|
|
.name = "On",
|
|
},
|
|
[WDRM_DPMS_STATE_STANDBY] = {
|
|
.name = "Standby",
|
|
},
|
|
[WDRM_DPMS_STATE_SUSPEND] = {
|
|
.name = "Suspend",
|
|
},
|
|
};
|
|
|
|
struct drm_property_enum_info content_protection_enums[] = {
|
|
[WDRM_CONTENT_PROTECTION_UNDESIRED] = {
|
|
.name = "Undesired",
|
|
},
|
|
[WDRM_CONTENT_PROTECTION_DESIRED] = {
|
|
.name = "Desired",
|
|
},
|
|
[WDRM_CONTENT_PROTECTION_ENABLED] = {
|
|
.name = "Enabled",
|
|
},
|
|
};
|
|
|
|
struct drm_property_enum_info hdcp_content_type_enums[] = {
|
|
[WDRM_HDCP_CONTENT_TYPE0] = {
|
|
.name = "HDCP Type0",
|
|
},
|
|
[WDRM_HDCP_CONTENT_TYPE1] = {
|
|
.name = "HDCP Type1",
|
|
},
|
|
};
|
|
|
|
struct drm_property_enum_info panel_orientation_enums[] = {
|
|
[WDRM_PANEL_ORIENTATION_NORMAL] = { .name = "Normal", },
|
|
[WDRM_PANEL_ORIENTATION_UPSIDE_DOWN] = { .name = "Upside Down", },
|
|
[WDRM_PANEL_ORIENTATION_LEFT_SIDE_UP] = { .name = "Left Side Up", },
|
|
[WDRM_PANEL_ORIENTATION_RIGHT_SIDE_UP] = { .name = "Right Side Up", },
|
|
};
|
|
|
|
struct drm_property_enum_info content_type_enums[] = {
|
|
[WDRM_CONTENT_TYPE_NO_DATA] = { .name = "No Data", },
|
|
[WDRM_CONTENT_TYPE_GRAPHICS] = { .name = "Graphics", },
|
|
[WDRM_CONTENT_TYPE_PHOTO] = { .name = "Photo", },
|
|
[WDRM_CONTENT_TYPE_CINEMA] = { .name = "Cinema", },
|
|
[WDRM_CONTENT_TYPE_GAME] = { .name = "Game", },
|
|
};
|
|
|
|
const struct drm_property_info connector_props[] = {
|
|
[WDRM_CONNECTOR_EDID] = { .name = "EDID" },
|
|
[WDRM_CONNECTOR_DPMS] = {
|
|
.name = "DPMS",
|
|
.enum_values = dpms_state_enums,
|
|
.num_enum_values = WDRM_DPMS_STATE__COUNT,
|
|
},
|
|
[WDRM_CONNECTOR_CRTC_ID] = { .name = "CRTC_ID", },
|
|
[WDRM_CONNECTOR_WRITEBACK_PIXEL_FORMATS] = { .name = "WRITEBACK_PIXEL_FORMATS", },
|
|
[WDRM_CONNECTOR_WRITEBACK_FB_ID] = { .name = "WRITEBACK_FB_ID", },
|
|
[WDRM_CONNECTOR_WRITEBACK_OUT_FENCE_PTR] = { .name = "WRITEBACK_OUT_FENCE_PTR", },
|
|
[WDRM_CONNECTOR_NON_DESKTOP] = { .name = "non-desktop", },
|
|
[WDRM_CONNECTOR_CONTENT_PROTECTION] = {
|
|
.name = "Content Protection",
|
|
.enum_values = content_protection_enums,
|
|
.num_enum_values = WDRM_CONTENT_PROTECTION__COUNT,
|
|
},
|
|
[WDRM_CONNECTOR_HDCP_CONTENT_TYPE] = {
|
|
.name = "HDCP Content Type",
|
|
.enum_values = hdcp_content_type_enums,
|
|
.num_enum_values = WDRM_HDCP_CONTENT_TYPE__COUNT,
|
|
},
|
|
[WDRM_CONNECTOR_PANEL_ORIENTATION] = {
|
|
.name = "panel orientation",
|
|
.enum_values = panel_orientation_enums,
|
|
.num_enum_values = WDRM_PANEL_ORIENTATION__COUNT,
|
|
},
|
|
[WDRM_CONNECTOR_HDR_OUTPUT_METADATA] = {
|
|
.name = "HDR_OUTPUT_METADATA",
|
|
},
|
|
[WDRM_CONNECTOR_MAX_BPC] = { .name = "max bpc", },
|
|
[WDRM_CONNECTOR_CONTENT_TYPE] = {
|
|
.name = "content type",
|
|
.enum_values = content_type_enums,
|
|
.num_enum_values = WDRM_CONTENT_TYPE__COUNT,
|
|
},
|
|
};
|
|
|
|
const struct drm_property_info crtc_props[] = {
|
|
[WDRM_CRTC_MODE_ID] = { .name = "MODE_ID", },
|
|
[WDRM_CRTC_ACTIVE] = { .name = "ACTIVE", },
|
|
[WDRM_CRTC_CTM] = { .name = "CTM", },
|
|
[WDRM_CRTC_DEGAMMA_LUT] = { .name = "DEGAMMA_LUT", },
|
|
[WDRM_CRTC_DEGAMMA_LUT_SIZE] = { .name = "DEGAMMA_LUT_SIZE", },
|
|
[WDRM_CRTC_GAMMA_LUT] = { .name = "GAMMA_LUT", },
|
|
[WDRM_CRTC_GAMMA_LUT_SIZE] = { .name = "GAMMA_LUT_SIZE", },
|
|
[WDRM_CRTC_VRR_ENABLED] = { .name = "VRR_ENABLED", },
|
|
};
|
|
|
|
|
|
/**
|
|
* Mode for drm_pending_state_apply and co.
|
|
*/
|
|
enum drm_state_apply_mode {
|
|
DRM_STATE_APPLY_SYNC, /**< state fully processed */
|
|
DRM_STATE_APPLY_ASYNC, /**< state pending event delivery */
|
|
DRM_STATE_TEST_ONLY, /**< test if the state can be applied */
|
|
};
|
|
|
|
/**
|
|
* Get the current value of a KMS property
|
|
*
|
|
* Given a drmModeObjectGetProperties return, as well as the drm_property_info
|
|
* for the target property, return the current value of that property,
|
|
* with an optional default. If the property is a KMS enum type, the return
|
|
* value will be translated into the appropriate internal enum.
|
|
*
|
|
* If the property is not present, the default value will be returned.
|
|
*
|
|
* @param info Internal structure for property to look up
|
|
* @param props Raw KMS properties for the target object
|
|
* @param def Value to return if property is not found
|
|
*/
|
|
uint64_t
|
|
drm_property_get_value(struct drm_property_info *info,
|
|
const drmModeObjectProperties *props,
|
|
uint64_t def)
|
|
{
|
|
unsigned int i;
|
|
|
|
if (info->prop_id == 0)
|
|
return def;
|
|
|
|
for (i = 0; i < props->count_props; i++) {
|
|
unsigned int j;
|
|
|
|
if (props->props[i] != info->prop_id)
|
|
continue;
|
|
|
|
/* Simple (non-enum) types can return the value directly */
|
|
if (info->num_enum_values == 0)
|
|
return props->prop_values[i];
|
|
|
|
/* Map from raw value to enum value */
|
|
for (j = 0; j < info->num_enum_values; j++) {
|
|
if (!info->enum_values[j].valid)
|
|
continue;
|
|
if (info->enum_values[j].value != props->prop_values[i])
|
|
continue;
|
|
|
|
return j;
|
|
}
|
|
|
|
/* We don't have a mapping for this enum; return default. */
|
|
break;
|
|
}
|
|
|
|
return def;
|
|
}
|
|
|
|
/**
|
|
* Get the current range values of a KMS property
|
|
*
|
|
* Given a drmModeObjectGetProperties return, as well as the drm_property_info
|
|
* for the target property, return the current range values of that property,
|
|
*
|
|
* If the property is not present, or there's no it is not a prop range then
|
|
* NULL will be returned.
|
|
*
|
|
* @param info Internal structure for property to look up
|
|
* @param props Raw KMS properties for the target object
|
|
*/
|
|
uint64_t *
|
|
drm_property_get_range_values(struct drm_property_info *info,
|
|
const drmModeObjectProperties *props)
|
|
{
|
|
unsigned int i;
|
|
|
|
if (info->prop_id == 0)
|
|
return NULL;
|
|
|
|
for (i = 0; i < props->count_props; i++) {
|
|
|
|
if (props->props[i] != info->prop_id)
|
|
continue;
|
|
|
|
if (!(info->flags & DRM_MODE_PROP_RANGE) &&
|
|
!(info->flags & DRM_MODE_PROP_SIGNED_RANGE))
|
|
continue;
|
|
|
|
return info->range_values;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* We use the fact that 0 is not a valid rotation here - if we return 0,
|
|
* the plane doesn't support the rotation requested. Otherwise the correct
|
|
* value to achieve the requested rotation on this plane is returned.
|
|
*/
|
|
uint64_t
|
|
drm_rotation_from_output_transform(struct drm_plane *plane,
|
|
enum wl_output_transform ot)
|
|
{
|
|
struct drm_property_info *info = &plane->props[WDRM_PLANE_ROTATION];
|
|
enum wdrm_plane_rotation drm_rotation;
|
|
enum wdrm_plane_rotation drm_reflection = 0;
|
|
uint64_t out = 0;
|
|
|
|
if (info->prop_id == 0) {
|
|
if (ot == WL_OUTPUT_TRANSFORM_NORMAL)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
switch (ot) {
|
|
case WL_OUTPUT_TRANSFORM_NORMAL:
|
|
drm_rotation = WDRM_PLANE_ROTATION_0;
|
|
break;
|
|
case WL_OUTPUT_TRANSFORM_90:
|
|
drm_rotation = WDRM_PLANE_ROTATION_90;
|
|
break;
|
|
case WL_OUTPUT_TRANSFORM_180:
|
|
drm_rotation = WDRM_PLANE_ROTATION_180;
|
|
break;
|
|
case WL_OUTPUT_TRANSFORM_270:
|
|
drm_rotation = WDRM_PLANE_ROTATION_270;
|
|
break;
|
|
case WL_OUTPUT_TRANSFORM_FLIPPED:
|
|
drm_rotation = WDRM_PLANE_ROTATION_0;
|
|
drm_reflection = WDRM_PLANE_ROTATION_REFLECT_X;
|
|
break;
|
|
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
|
|
drm_rotation = WDRM_PLANE_ROTATION_90;
|
|
drm_reflection = WDRM_PLANE_ROTATION_REFLECT_X;
|
|
break;
|
|
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
|
|
drm_rotation = WDRM_PLANE_ROTATION_180;
|
|
drm_reflection = WDRM_PLANE_ROTATION_REFLECT_X;
|
|
break;
|
|
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
|
|
drm_rotation = WDRM_PLANE_ROTATION_270;
|
|
drm_reflection = WDRM_PLANE_ROTATION_REFLECT_X;
|
|
break;
|
|
default:
|
|
assert(0 && "bad output transform");
|
|
}
|
|
|
|
if (!info->enum_values[drm_rotation].valid)
|
|
return 0;
|
|
|
|
out |= 1 << info->enum_values[drm_rotation].value;
|
|
|
|
if (drm_reflection) {
|
|
if (!info->enum_values[drm_reflection].valid)
|
|
return 0;
|
|
out |= 1 << info->enum_values[drm_reflection].value;
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
/**
|
|
* Cache DRM property values
|
|
*
|
|
* Update a per-object array of drm_property_info structures, given the
|
|
* DRM properties of the object.
|
|
*
|
|
* Call this every time an object newly appears (note that only connectors
|
|
* can be hotplugged), the first time it is seen, or when its status changes
|
|
* in a way which invalidates the potential property values (currently, the
|
|
* only case for this is connector hotplug).
|
|
*
|
|
* This updates the property IDs and enum values within the drm_property_info
|
|
* array.
|
|
*
|
|
* DRM property enum values are dynamic at runtime; the user must query the
|
|
* property to find out the desired runtime value for a requested string
|
|
* name. Using the 'type' field on planes as an example, there is no single
|
|
* hardcoded constant for primary plane types; instead, the property must be
|
|
* queried at runtime to find the value associated with the string "Primary".
|
|
*
|
|
* This helper queries and caches the enum values, to allow us to use a set
|
|
* of compile-time-constant enums portably across various implementations.
|
|
* The values given in enum_names are searched for, and stored in the
|
|
* same-indexed field of the map array.
|
|
*
|
|
* @param device DRM device object
|
|
* @param src DRM property info array to source from
|
|
* @param info DRM property info array to copy into
|
|
* @param num_infos Number of entries in the source array
|
|
* @param props DRM object properties for the object
|
|
*/
|
|
void
|
|
drm_property_info_populate(struct drm_device *device,
|
|
const struct drm_property_info *src,
|
|
struct drm_property_info *info,
|
|
unsigned int num_infos,
|
|
drmModeObjectProperties *props)
|
|
{
|
|
drmModePropertyRes *prop;
|
|
unsigned i, j;
|
|
|
|
for (i = 0; i < num_infos; i++) {
|
|
unsigned int j;
|
|
|
|
info[i].name = src[i].name;
|
|
info[i].prop_id = 0;
|
|
info[i].num_enum_values = src[i].num_enum_values;
|
|
|
|
if (src[i].num_enum_values == 0)
|
|
continue;
|
|
|
|
info[i].enum_values =
|
|
malloc(src[i].num_enum_values *
|
|
sizeof(*info[i].enum_values));
|
|
assert(info[i].enum_values);
|
|
for (j = 0; j < info[i].num_enum_values; j++) {
|
|
info[i].enum_values[j].name = src[i].enum_values[j].name;
|
|
info[i].enum_values[j].valid = false;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < props->count_props; i++) {
|
|
unsigned int k;
|
|
|
|
prop = drmModeGetProperty(device->drm.fd, props->props[i]);
|
|
if (!prop)
|
|
continue;
|
|
|
|
for (j = 0; j < num_infos; j++) {
|
|
if (!strcmp(prop->name, info[j].name))
|
|
break;
|
|
}
|
|
|
|
/* We don't know/care about this property. */
|
|
if (j == num_infos) {
|
|
#ifdef DEBUG
|
|
weston_log("DRM debug: unrecognized property %u '%s'\n",
|
|
prop->prop_id, prop->name);
|
|
#endif
|
|
drmModeFreeProperty(prop);
|
|
continue;
|
|
}
|
|
|
|
if (info[j].num_enum_values == 0 &&
|
|
(prop->flags & DRM_MODE_PROP_ENUM)) {
|
|
weston_log("DRM: expected property %s to not be an"
|
|
" enum, but it is; ignoring\n", prop->name);
|
|
drmModeFreeProperty(prop);
|
|
continue;
|
|
}
|
|
|
|
info[j].prop_id = props->props[i];
|
|
info[j].flags = prop->flags;
|
|
|
|
if (prop->flags & DRM_MODE_PROP_RANGE ||
|
|
prop->flags & DRM_MODE_PROP_SIGNED_RANGE) {
|
|
info[j].num_range_values = prop->count_values;
|
|
for (int i = 0; i < prop->count_values; i++)
|
|
info[j].range_values[i] = prop->values[i];
|
|
}
|
|
|
|
|
|
if (info[j].num_enum_values == 0) {
|
|
drmModeFreeProperty(prop);
|
|
continue;
|
|
}
|
|
|
|
if (!(prop->flags & DRM_MODE_PROP_ENUM) &&
|
|
!(prop->flags & DRM_MODE_PROP_BITMASK)) {
|
|
weston_log("DRM: expected property %s to be an enum"
|
|
" or bitmask, but it is not; ignoring\n",
|
|
prop->name);
|
|
drmModeFreeProperty(prop);
|
|
info[j].prop_id = 0;
|
|
continue;
|
|
}
|
|
|
|
for (k = 0; k < info[j].num_enum_values; k++) {
|
|
int l;
|
|
|
|
for (l = 0; l < prop->count_enums; l++) {
|
|
if (!strcmp(prop->enums[l].name,
|
|
info[j].enum_values[k].name))
|
|
break;
|
|
}
|
|
|
|
if (l == prop->count_enums)
|
|
continue;
|
|
|
|
info[j].enum_values[k].valid = true;
|
|
info[j].enum_values[k].value = prop->enums[l].value;
|
|
}
|
|
|
|
drmModeFreeProperty(prop);
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
for (i = 0; i < num_infos; i++) {
|
|
if (info[i].prop_id == 0)
|
|
weston_log("DRM warning: property '%s' missing\n",
|
|
info[i].name);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* Free DRM property information
|
|
*
|
|
* Frees all memory associated with a DRM property info array and zeroes
|
|
* it out, leaving it usable for a further drm_property_info_update() or
|
|
* drm_property_info_free().
|
|
*
|
|
* @param info DRM property info array
|
|
* @param num_props Number of entries in array to free
|
|
*/
|
|
void
|
|
drm_property_info_free(struct drm_property_info *info, int num_props)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < num_props; i++)
|
|
free(info[i].enum_values);
|
|
|
|
memset(info, 0, sizeof(*info) * num_props);
|
|
}
|
|
|
|
/**
|
|
* Populates the plane's formats array, using either the IN_FORMATS blob
|
|
* property (if available), or the plane's format list if not.
|
|
*/
|
|
int
|
|
drm_plane_populate_formats(struct drm_plane *plane, const drmModePlane *kplane,
|
|
const drmModeObjectProperties *props,
|
|
const bool use_modifiers)
|
|
{
|
|
struct drm_device *device = plane->device;
|
|
uint32_t i, blob_id, fmt_prev = DRM_FORMAT_INVALID;
|
|
drmModeFormatModifierIterator drm_iter = {0};
|
|
struct weston_drm_format *fmt = NULL;
|
|
drmModePropertyBlobRes *blob = NULL;
|
|
int ret = 0;
|
|
|
|
if (!use_modifiers)
|
|
goto fallback;
|
|
|
|
blob_id = drm_property_get_value(&plane->props[WDRM_PLANE_IN_FORMATS],
|
|
props,
|
|
0);
|
|
if (blob_id == 0)
|
|
goto fallback;
|
|
|
|
blob = drmModeGetPropertyBlob(device->drm.fd, blob_id);
|
|
if (!blob)
|
|
goto fallback;
|
|
|
|
while (drmModeFormatModifierBlobIterNext(blob, &drm_iter)) {
|
|
if (fmt_prev != drm_iter.fmt) {
|
|
fmt = weston_drm_format_array_add_format(&plane->formats,
|
|
drm_iter.fmt);
|
|
if (!fmt) {
|
|
ret = -1;
|
|
goto out;
|
|
}
|
|
|
|
fmt_prev = drm_iter.fmt;
|
|
}
|
|
|
|
ret = weston_drm_format_add_modifier(fmt, drm_iter.mod);
|
|
if (ret < 0)
|
|
goto out;
|
|
|
|
}
|
|
|
|
out:
|
|
drmModeFreePropertyBlob(blob);
|
|
return ret;
|
|
|
|
fallback:
|
|
/* No IN_FORMATS blob available, so just use the old. */
|
|
for (i = 0; i < kplane->count_formats; i++) {
|
|
fmt = weston_drm_format_array_add_format(&plane->formats,
|
|
kplane->formats[i]);
|
|
if (!fmt)
|
|
return -1;
|
|
ret = weston_drm_format_add_modifier(fmt, DRM_FORMAT_MOD_INVALID);
|
|
if (ret < 0)
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
drm_output_set_gamma(struct weston_output *output_base,
|
|
uint16_t size, uint16_t *r, uint16_t *g, uint16_t *b)
|
|
{
|
|
int rc;
|
|
struct drm_output *output = to_drm_output(output_base);
|
|
struct drm_device *device = output->device;
|
|
|
|
assert(output);
|
|
|
|
/* check */
|
|
if (output_base->gamma_size != size)
|
|
return;
|
|
|
|
output->deprecated_gamma_is_set = true;
|
|
rc = drmModeCrtcSetGamma(device->drm.fd,
|
|
output->crtc->crtc_id,
|
|
size, r, g, b);
|
|
if (rc)
|
|
weston_log("set gamma failed: %s\n", strerror(errno));
|
|
}
|
|
|
|
/**
|
|
* Mark an output state as current on the output, i.e. it has been
|
|
* submitted to the kernel. The mode argument determines whether this
|
|
* update will be applied synchronously (e.g. when calling drmModeSetCrtc),
|
|
* or asynchronously (in which case we wait for events to complete).
|
|
*/
|
|
static void
|
|
drm_output_assign_state(struct drm_output_state *state,
|
|
enum drm_state_apply_mode mode)
|
|
{
|
|
struct drm_output *output = state->output;
|
|
struct drm_device *device = output->device;
|
|
struct drm_backend *b = device->backend;
|
|
struct drm_plane_state *plane_state;
|
|
struct drm_head *head;
|
|
|
|
assert(!output->state_last);
|
|
|
|
if (mode == DRM_STATE_APPLY_ASYNC)
|
|
output->state_last = output->state_cur;
|
|
else
|
|
drm_output_state_free(output->state_cur);
|
|
|
|
wl_list_remove(&state->link);
|
|
wl_list_init(&state->link);
|
|
state->pending_state = NULL;
|
|
|
|
output->state_cur = state;
|
|
|
|
if (device->atomic_modeset && mode == DRM_STATE_APPLY_ASYNC) {
|
|
drm_debug(b, "\t[CRTC:%u] setting pending flip\n",
|
|
output->crtc->crtc_id);
|
|
output->atomic_complete_pending = true;
|
|
}
|
|
|
|
if (device->atomic_modeset &&
|
|
state->protection == WESTON_HDCP_DISABLE)
|
|
wl_list_for_each(head, &output->base.head_list, base.output_link)
|
|
weston_head_set_content_protection_status(&head->base,
|
|
WESTON_HDCP_DISABLE);
|
|
|
|
/* Replace state_cur on each affected plane with the new state, being
|
|
* careful to dispose of orphaned (but only orphaned) previous state.
|
|
* If the previous state is not orphaned (still has an output_state
|
|
* attached), it will be disposed of by freeing the output_state. */
|
|
wl_list_for_each(plane_state, &state->plane_list, link) {
|
|
struct drm_plane *plane = plane_state->plane;
|
|
|
|
if (plane->state_cur && !plane->state_cur->output_state)
|
|
drm_plane_state_free(plane->state_cur, true);
|
|
plane->state_cur = plane_state;
|
|
|
|
if (mode != DRM_STATE_APPLY_ASYNC) {
|
|
plane_state->complete = true;
|
|
continue;
|
|
}
|
|
|
|
if (device->atomic_modeset)
|
|
continue;
|
|
|
|
assert(plane->type != WDRM_PLANE_TYPE_OVERLAY);
|
|
if (plane->type == WDRM_PLANE_TYPE_PRIMARY)
|
|
output->page_flip_pending = true;
|
|
}
|
|
}
|
|
|
|
static void
|
|
drm_output_set_cursor(struct drm_output_state *output_state)
|
|
{
|
|
struct drm_output *output = output_state->output;
|
|
struct drm_device *device = output->device;
|
|
struct drm_crtc *crtc = output->crtc;
|
|
struct drm_plane *plane = output->cursor_plane;
|
|
struct drm_plane_state *state;
|
|
uint32_t handle;
|
|
|
|
if (!plane)
|
|
return;
|
|
|
|
state = drm_output_state_get_existing_plane(output_state, plane);
|
|
if (!state)
|
|
return;
|
|
|
|
if (!state->fb) {
|
|
drmModeSetCursor(device->drm.fd, crtc->crtc_id, 0, 0, 0);
|
|
return;
|
|
}
|
|
|
|
assert(state->fb == output->gbm_cursor_fb[output->current_cursor]);
|
|
assert(!plane->state_cur->output || plane->state_cur->output == output);
|
|
|
|
handle = output->gbm_cursor_handle[output->current_cursor];
|
|
if (plane->state_cur->fb != state->fb) {
|
|
if (drmModeSetCursor(device->drm.fd, crtc->crtc_id, handle,
|
|
device->cursor_width, device->cursor_height)) {
|
|
weston_log("failed to set cursor: %s\n",
|
|
strerror(errno));
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
if (drmModeMoveCursor(device->drm.fd, crtc->crtc_id,
|
|
state->dest_x, state->dest_y)) {
|
|
weston_log("failed to move cursor: %s\n", strerror(errno));
|
|
goto err;
|
|
}
|
|
|
|
return;
|
|
|
|
err:
|
|
device->cursors_are_broken = true;
|
|
drmModeSetCursor(device->drm.fd, crtc->crtc_id, 0, 0, 0);
|
|
}
|
|
|
|
static void
|
|
drm_output_reset_legacy_gamma(struct drm_output *output)
|
|
{
|
|
uint32_t len = output->base.gamma_size;
|
|
uint16_t *lut;
|
|
uint32_t i;
|
|
int ret;
|
|
|
|
if (len == 0)
|
|
return;
|
|
|
|
if (output->legacy_gamma_not_supported)
|
|
return;
|
|
|
|
lut = calloc(len, sizeof(uint16_t));
|
|
if (!lut)
|
|
return;
|
|
|
|
/* Identity curve */
|
|
for (i = 0; i < len; i++)
|
|
lut[i] = 0xffff * i / (len - 1);
|
|
|
|
ret = drmModeCrtcSetGamma(output->device->drm.fd,
|
|
output->crtc->crtc_id,
|
|
len, lut, lut, lut);
|
|
if (ret == -EOPNOTSUPP || ret == -ENOSYS)
|
|
output->legacy_gamma_not_supported = true;
|
|
else if (ret < 0) {
|
|
weston_log("%s failed for %s: %s\n", __func__,
|
|
output->base.name, strerror(-ret));
|
|
}
|
|
|
|
free(lut);
|
|
}
|
|
|
|
static int
|
|
drm_output_apply_state_legacy(struct drm_output_state *state)
|
|
{
|
|
struct drm_output *output = state->output;
|
|
struct drm_device *device = output->device;
|
|
struct drm_backend *backend = device->backend;
|
|
struct drm_plane *scanout_plane = output->scanout_plane;
|
|
struct drm_crtc *crtc = output->crtc;
|
|
struct drm_property_info *dpms_prop;
|
|
struct drm_plane_state *scanout_state;
|
|
struct drm_mode *mode;
|
|
struct drm_head *head;
|
|
const struct pixel_format_info *pinfo = NULL;
|
|
uint32_t connectors[MAX_CLONED_CONNECTORS];
|
|
int n_conn = 0;
|
|
struct timespec now;
|
|
int ret = 0;
|
|
|
|
wl_list_for_each(head, &output->base.head_list, base.output_link) {
|
|
assert(n_conn < MAX_CLONED_CONNECTORS);
|
|
connectors[n_conn++] = head->connector.connector_id;
|
|
}
|
|
|
|
/* If disable_planes is set then assign_planes() wasn't
|
|
* called for this render, so we could still have a stale
|
|
* cursor plane set up.
|
|
*/
|
|
if (output->base.disable_planes) {
|
|
drm_output_set_cursor_view(output, NULL);
|
|
if (output->cursor_plane) {
|
|
output->cursor_plane->base.x = INT32_MIN;
|
|
output->cursor_plane->base.y = INT32_MIN;
|
|
}
|
|
}
|
|
|
|
if (state->dpms != WESTON_DPMS_ON) {
|
|
if (output->cursor_plane) {
|
|
ret = drmModeSetCursor(device->drm.fd, crtc->crtc_id,
|
|
0, 0, 0);
|
|
if (ret)
|
|
weston_log("drmModeSetCursor failed disable: %s\n",
|
|
strerror(errno));
|
|
}
|
|
|
|
ret = drmModeSetCrtc(device->drm.fd, crtc->crtc_id, 0, 0, 0,
|
|
NULL, 0, NULL);
|
|
if (ret)
|
|
weston_log("drmModeSetCrtc failed disabling: %s\n",
|
|
strerror(errno));
|
|
|
|
drm_output_assign_state(state, DRM_STATE_APPLY_SYNC);
|
|
weston_compositor_read_presentation_clock(output->base.compositor, &now);
|
|
drm_output_update_complete(output,
|
|
WP_PRESENTATION_FEEDBACK_KIND_HW_COMPLETION,
|
|
now.tv_sec, now.tv_nsec / 1000);
|
|
|
|
return 0;
|
|
}
|
|
|
|
scanout_state =
|
|
drm_output_state_get_existing_plane(state, scanout_plane);
|
|
|
|
/* The legacy SetCrtc API doesn't allow us to do scaling, and the
|
|
* legacy PageFlip API doesn't allow us to do clipping either. */
|
|
assert(scanout_state->src_x == 0);
|
|
assert(scanout_state->src_y == 0);
|
|
assert(scanout_state->src_w ==
|
|
(unsigned) (output->base.current_mode->width << 16));
|
|
assert(scanout_state->src_h ==
|
|
(unsigned) (output->base.current_mode->height << 16));
|
|
assert(scanout_state->dest_x == 0);
|
|
assert(scanout_state->dest_y == 0);
|
|
assert(scanout_state->dest_w == scanout_state->src_w >> 16);
|
|
assert(scanout_state->dest_h == scanout_state->src_h >> 16);
|
|
/* The legacy SetCrtc API doesn't support fences */
|
|
assert(scanout_state->in_fence_fd == -1);
|
|
|
|
mode = to_drm_mode(output->base.current_mode);
|
|
if (device->state_invalid ||
|
|
!scanout_plane->state_cur->fb ||
|
|
scanout_plane->state_cur->fb->strides[0] !=
|
|
scanout_state->fb->strides[0]) {
|
|
|
|
ret = drmModeSetCrtc(device->drm.fd, crtc->crtc_id,
|
|
scanout_state->fb->fb_id,
|
|
0, 0,
|
|
connectors, n_conn,
|
|
&mode->mode_info);
|
|
if (ret) {
|
|
weston_log("set mode failed: %s\n", strerror(errno));
|
|
goto err;
|
|
}
|
|
|
|
if (!output->deprecated_gamma_is_set)
|
|
drm_output_reset_legacy_gamma(output);
|
|
}
|
|
|
|
pinfo = scanout_state->fb->format;
|
|
drm_debug(backend, "\t[CRTC:%u, PLANE:%u] FORMAT: %s\n",
|
|
crtc->crtc_id, scanout_state->plane->plane_id,
|
|
pinfo ? pinfo->drm_format_name : "UNKNOWN");
|
|
|
|
if (drmModePageFlip(device->drm.fd, crtc->crtc_id,
|
|
scanout_state->fb->fb_id,
|
|
DRM_MODE_PAGE_FLIP_EVENT, output) < 0) {
|
|
weston_log("queueing pageflip failed: %s\n", strerror(errno));
|
|
goto err;
|
|
}
|
|
|
|
assert(!output->page_flip_pending);
|
|
|
|
if (output->pageflip_timer)
|
|
wl_event_source_timer_update(output->pageflip_timer,
|
|
backend->pageflip_timeout);
|
|
|
|
drm_output_set_cursor(state);
|
|
|
|
if (state->dpms != output->state_cur->dpms) {
|
|
wl_list_for_each(head, &output->base.head_list, base.output_link) {
|
|
dpms_prop = &head->connector.props[WDRM_CONNECTOR_DPMS];
|
|
if (dpms_prop->prop_id == 0)
|
|
continue;
|
|
|
|
ret = drmModeConnectorSetProperty(device->drm.fd,
|
|
head->connector.connector_id,
|
|
dpms_prop->prop_id,
|
|
state->dpms);
|
|
if (ret) {
|
|
weston_log("DRM: DPMS: failed property set for %s\n",
|
|
head->base.name);
|
|
}
|
|
}
|
|
}
|
|
|
|
drm_output_assign_state(state, DRM_STATE_APPLY_ASYNC);
|
|
|
|
return 0;
|
|
|
|
err:
|
|
drm_output_set_cursor_view(output, NULL);
|
|
drm_output_state_free(state);
|
|
return -1;
|
|
}
|
|
|
|
static int
|
|
crtc_add_prop(drmModeAtomicReq *req, struct drm_crtc *crtc,
|
|
enum wdrm_crtc_property prop, uint64_t val)
|
|
{
|
|
struct drm_device *device = crtc->device;
|
|
struct drm_backend *b = device->backend;
|
|
struct drm_property_info *info = &crtc->props_crtc[prop];
|
|
int ret;
|
|
|
|
drm_debug(b, "\t\t\t[CRTC:%lu] %lu (%s) -> %llu (0x%llx)\n",
|
|
(unsigned long) crtc->crtc_id,
|
|
(unsigned long) info->prop_id, info->name,
|
|
(unsigned long long) val, (unsigned long long) val);
|
|
|
|
if (info->prop_id == 0)
|
|
return -1;
|
|
|
|
ret = drmModeAtomicAddProperty(req, crtc->crtc_id, info->prop_id,
|
|
val);
|
|
return (ret <= 0) ? -1 : 0;
|
|
}
|
|
|
|
/** Set a CRTC property, allowing zero value for non-existing property
|
|
*
|
|
* \param req The atomic KMS request to append to.
|
|
* \param crtc The CRTC whose property to set.
|
|
* \param prop Which CRTC property to set.
|
|
* \param val The value, cast to u64, to set to the CRTC property.
|
|
* \return 0 on succcess, -1 on failure.
|
|
*
|
|
* If the property does not exist, attempting to set it to value
|
|
* zero is ok, because the property with value zero has the same
|
|
* KMS effect as the property not existing.
|
|
*
|
|
* However, trying to set a non-existing property to a non-zero value
|
|
* must fail, because that would not achieve the desired KMS effect.
|
|
*
|
|
* It is up to the caller to understand which KMS properties work
|
|
* like this and which do not.
|
|
*/
|
|
static int
|
|
crtc_add_prop_zero_ok(drmModeAtomicReq *req, struct drm_crtc *crtc,
|
|
enum wdrm_crtc_property prop, uint64_t val)
|
|
{
|
|
struct drm_property_info *info = &crtc->props_crtc[prop];
|
|
|
|
if (info->prop_id == 0 && val == 0)
|
|
return 0;
|
|
|
|
return crtc_add_prop(req, crtc, prop, val);
|
|
}
|
|
|
|
static int
|
|
connector_add_prop(drmModeAtomicReq *req, struct drm_connector *connector,
|
|
enum wdrm_connector_property prop, uint64_t val)
|
|
{
|
|
struct drm_device *device = connector->device;
|
|
struct drm_backend *b = device->backend;
|
|
struct drm_property_info *info = &connector->props[prop];
|
|
uint32_t connector_id = connector->connector_id;
|
|
int ret;
|
|
|
|
drm_debug(b, "\t\t\t[CONN:%lu] %lu (%s) -> %llu (0x%llx)\n",
|
|
(unsigned long) connector_id,
|
|
(unsigned long) info->prop_id, info->name,
|
|
(unsigned long long) val, (unsigned long long) val);
|
|
|
|
if (info->prop_id == 0)
|
|
return -1;
|
|
|
|
ret = drmModeAtomicAddProperty(req, connector_id, info->prop_id, val);
|
|
return (ret <= 0) ? -1 : 0;
|
|
}
|
|
|
|
static int
|
|
plane_add_prop(drmModeAtomicReq *req, struct drm_plane *plane,
|
|
enum wdrm_plane_property prop, uint64_t val)
|
|
{
|
|
struct drm_device *device = plane->device;
|
|
struct drm_backend *b = device->backend;
|
|
struct drm_property_info *info = &plane->props[prop];
|
|
int ret;
|
|
|
|
drm_debug(b, "\t\t\t[PLANE:%lu] %lu (%s) -> %llu (0x%llx)\n",
|
|
(unsigned long) plane->plane_id,
|
|
(unsigned long) info->prop_id, info->name,
|
|
(unsigned long long) val, (unsigned long long) val);
|
|
|
|
if (info->prop_id == 0)
|
|
return -1;
|
|
|
|
ret = drmModeAtomicAddProperty(req, plane->plane_id, info->prop_id,
|
|
val);
|
|
return (ret <= 0) ? -1 : 0;
|
|
}
|
|
|
|
static bool
|
|
drm_connector_has_prop(struct drm_connector *connector,
|
|
enum wdrm_connector_property prop)
|
|
{
|
|
if (connector->props[prop].prop_id != 0)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* This function converts the protection requests from weston_hdcp_protection
|
|
* corresponding drm values. These values can be set in "Content Protection"
|
|
* & "HDCP Content Type" connector properties.
|
|
*/
|
|
static void
|
|
get_drm_protection_from_weston(enum weston_hdcp_protection weston_protection,
|
|
enum wdrm_content_protection_state *drm_protection,
|
|
enum wdrm_hdcp_content_type *drm_cp_type)
|
|
{
|
|
|
|
switch (weston_protection) {
|
|
case WESTON_HDCP_DISABLE:
|
|
*drm_protection = WDRM_CONTENT_PROTECTION_UNDESIRED;
|
|
*drm_cp_type = WDRM_HDCP_CONTENT_TYPE0;
|
|
break;
|
|
case WESTON_HDCP_ENABLE_TYPE_0:
|
|
*drm_protection = WDRM_CONTENT_PROTECTION_DESIRED;
|
|
*drm_cp_type = WDRM_HDCP_CONTENT_TYPE0;
|
|
break;
|
|
case WESTON_HDCP_ENABLE_TYPE_1:
|
|
*drm_protection = WDRM_CONTENT_PROTECTION_DESIRED;
|
|
*drm_cp_type = WDRM_HDCP_CONTENT_TYPE1;
|
|
break;
|
|
default:
|
|
assert(0 && "bad weston_hdcp_protection");
|
|
}
|
|
}
|
|
|
|
static void
|
|
drm_connector_set_hdcp_property(struct drm_connector *connector,
|
|
enum weston_hdcp_protection protection,
|
|
drmModeAtomicReq *req)
|
|
{
|
|
int ret;
|
|
enum wdrm_content_protection_state drm_protection;
|
|
enum wdrm_hdcp_content_type drm_cp_type;
|
|
struct drm_property_enum_info *enum_info;
|
|
uint64_t prop_val;
|
|
struct drm_property_info *props = connector->props;
|
|
|
|
get_drm_protection_from_weston(protection, &drm_protection,
|
|
&drm_cp_type);
|
|
|
|
if (!drm_connector_has_prop(connector, WDRM_CONNECTOR_CONTENT_PROTECTION))
|
|
return;
|
|
|
|
/*
|
|
* Content-type property is not exposed for platforms not supporting
|
|
* HDCP2.2, therefore, type-1 cannot be supported. The type-0 content
|
|
* still can be supported if the content-protection property is exposed.
|
|
*/
|
|
if (!drm_connector_has_prop(connector, WDRM_CONNECTOR_HDCP_CONTENT_TYPE) &&
|
|
drm_cp_type != WDRM_HDCP_CONTENT_TYPE0)
|
|
return;
|
|
|
|
enum_info = props[WDRM_CONNECTOR_CONTENT_PROTECTION].enum_values;
|
|
prop_val = enum_info[drm_protection].value;
|
|
ret = connector_add_prop(req, connector,
|
|
WDRM_CONNECTOR_CONTENT_PROTECTION, prop_val);
|
|
assert(ret == 0);
|
|
|
|
if (!drm_connector_has_prop(connector, WDRM_CONNECTOR_HDCP_CONTENT_TYPE))
|
|
return;
|
|
|
|
enum_info = props[WDRM_CONNECTOR_HDCP_CONTENT_TYPE].enum_values;
|
|
prop_val = enum_info[drm_cp_type].value;
|
|
ret = connector_add_prop(req, connector,
|
|
WDRM_CONNECTOR_HDCP_CONTENT_TYPE, prop_val);
|
|
assert(ret == 0);
|
|
}
|
|
|
|
static int
|
|
drm_connector_set_max_bpc(struct drm_connector *connector,
|
|
struct drm_output *output,
|
|
drmModeAtomicReq *req)
|
|
{
|
|
const struct drm_property_info *info;
|
|
struct drm_head *head;
|
|
struct drm_backend *backend = output->device->backend;
|
|
uint64_t max_bpc;
|
|
uint64_t a, b;
|
|
|
|
if (!drm_connector_has_prop(connector, WDRM_CONNECTOR_MAX_BPC))
|
|
return 0;
|
|
|
|
if (output->max_bpc == 0) {
|
|
/* A value of 0 means that the current max_bpc must be programmed. */
|
|
head = drm_head_find_by_connector(backend, connector->connector_id);
|
|
max_bpc = head->inherited_max_bpc;
|
|
} else {
|
|
info = &connector->props[WDRM_CONNECTOR_MAX_BPC];
|
|
assert(info->flags & DRM_MODE_PROP_RANGE);
|
|
assert(info->num_range_values == 2);
|
|
a = info->range_values[0];
|
|
b = info->range_values[1];
|
|
assert(a <= b);
|
|
|
|
max_bpc = MAX(a, MIN(output->max_bpc, b));
|
|
}
|
|
|
|
return connector_add_prop(req, connector,
|
|
WDRM_CONNECTOR_MAX_BPC, max_bpc);
|
|
}
|
|
|
|
static int
|
|
drm_connector_set_content_type(struct drm_connector *connector,
|
|
enum wdrm_content_type content_type,
|
|
drmModeAtomicReq *req)
|
|
{
|
|
struct drm_property_enum_info *enum_info;
|
|
uint64_t prop_val;
|
|
struct drm_property_info *props = connector->props;
|
|
|
|
if (!drm_connector_has_prop(connector, WDRM_CONNECTOR_CONTENT_TYPE))
|
|
return 0;
|
|
|
|
enum_info = props[WDRM_CONNECTOR_CONTENT_TYPE].enum_values;
|
|
prop_val = enum_info[content_type].value;
|
|
return connector_add_prop(req, connector,
|
|
WDRM_CONNECTOR_CONTENT_TYPE, prop_val);
|
|
}
|
|
|
|
static int
|
|
drm_output_apply_state_atomic(struct drm_output_state *state,
|
|
drmModeAtomicReq *req,
|
|
uint32_t *flags)
|
|
{
|
|
struct drm_output *output = state->output;
|
|
struct drm_device *device = output->device;
|
|
struct drm_backend *b = device->backend;
|
|
struct drm_crtc *crtc = output->crtc;
|
|
struct drm_plane_state *plane_state;
|
|
struct drm_mode *current_mode = to_drm_mode(output->base.current_mode);
|
|
struct drm_head *head;
|
|
struct drm_head *tmp;
|
|
struct drm_writeback_state *wb_state = output->wb_state;
|
|
enum writeback_screenshot_state wb_screenshot_state =
|
|
drm_output_get_writeback_state(output);
|
|
int ret = 0;
|
|
|
|
drm_debug(b, "\t\t[atomic] %s output %lu (%s) state\n",
|
|
(*flags & DRM_MODE_ATOMIC_TEST_ONLY) ? "testing" : "applying",
|
|
(unsigned long) output->base.id, output->base.name);
|
|
|
|
if (state->dpms != output->state_cur->dpms) {
|
|
drm_debug(b, "\t\t\t[atomic] DPMS state differs, modeset OK\n");
|
|
*flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
|
|
}
|
|
|
|
if (wb_screenshot_state == DRM_OUTPUT_WB_SCREENSHOT_PREPARE_COMMIT) {
|
|
drm_debug(b, "\t\t\t[atomic] Writeback connector screenshot requested, modeset OK\n");
|
|
*flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
|
|
}
|
|
|
|
if (state->dpms == WESTON_DPMS_ON) {
|
|
ret = drm_mode_ensure_blob(device, current_mode);
|
|
if (ret != 0)
|
|
return ret;
|
|
|
|
ret |= crtc_add_prop(req, crtc, WDRM_CRTC_MODE_ID,
|
|
current_mode->blob_id);
|
|
ret |= crtc_add_prop(req, crtc, WDRM_CRTC_ACTIVE, 1);
|
|
|
|
if (!output->deprecated_gamma_is_set) {
|
|
ret |= crtc_add_prop_zero_ok(req, crtc,
|
|
WDRM_CRTC_GAMMA_LUT, 0);
|
|
ret |= crtc_add_prop_zero_ok(req, crtc,
|
|
WDRM_CRTC_DEGAMMA_LUT, 0);
|
|
}
|
|
ret |= crtc_add_prop_zero_ok(req, crtc, WDRM_CRTC_CTM, 0);
|
|
ret |= crtc_add_prop_zero_ok(req, crtc, WDRM_CRTC_VRR_ENABLED, 0);
|
|
|
|
/* No need for the DPMS property, since it is implicit in
|
|
* routing and CRTC activity. */
|
|
wl_list_for_each(head, &output->base.head_list, base.output_link) {
|
|
ret |= connector_add_prop(req, &head->connector,
|
|
WDRM_CONNECTOR_CRTC_ID,
|
|
crtc->crtc_id);
|
|
}
|
|
|
|
if (wb_screenshot_state == DRM_OUTPUT_WB_SCREENSHOT_PREPARE_COMMIT) {
|
|
ret |= connector_add_prop(req, &wb_state->wb->connector,
|
|
WDRM_CONNECTOR_CRTC_ID,
|
|
crtc->crtc_id);
|
|
ret |= connector_add_prop(req, &wb_state->wb->connector,
|
|
WDRM_CONNECTOR_WRITEBACK_FB_ID,
|
|
wb_state->fb->fb_id);
|
|
ret |= connector_add_prop(req, &wb_state->wb->connector,
|
|
WDRM_CONNECTOR_WRITEBACK_OUT_FENCE_PTR,
|
|
(uintptr_t)&wb_state->out_fence_fd);
|
|
if (!(*flags & DRM_MODE_ATOMIC_TEST_ONLY))
|
|
wb_state->state = DRM_OUTPUT_WB_SCREENSHOT_CHECK_FENCE;
|
|
}
|
|
} else {
|
|
ret |= crtc_add_prop(req, crtc, WDRM_CRTC_MODE_ID, 0);
|
|
ret |= crtc_add_prop(req, crtc, WDRM_CRTC_ACTIVE, 0);
|
|
|
|
if (wb_screenshot_state == DRM_OUTPUT_WB_SCREENSHOT_PREPARE_COMMIT) {
|
|
drm_debug(b, "\t\t\t[atomic] Writeback connector screenshot requested but CRTC is off\n");
|
|
drm_writeback_fail_screenshot(wb_state, "drm: CRTC is off");
|
|
}
|
|
|
|
/* No need for the DPMS property, since it is implicit in
|
|
* routing and CRTC activity. */
|
|
wl_list_for_each(head, &output->base.head_list, base.output_link)
|
|
ret |= connector_add_prop(req, &head->connector,
|
|
WDRM_CONNECTOR_CRTC_ID, 0);
|
|
|
|
wl_list_for_each_safe(head, tmp, &output->disable_head,
|
|
disable_head_link) {
|
|
ret |= connector_add_prop(req, &head->connector,
|
|
WDRM_CONNECTOR_CRTC_ID, 0);
|
|
wl_list_remove(&head->disable_head_link);
|
|
wl_list_init(&head->disable_head_link);
|
|
}
|
|
}
|
|
|
|
wl_list_for_each(head, &output->base.head_list, base.output_link) {
|
|
drm_connector_set_hdcp_property(&head->connector,
|
|
state->protection, req);
|
|
ret |= drm_connector_set_content_type(&head->connector,
|
|
output->content_type, req);
|
|
|
|
if (drm_connector_has_prop(&head->connector,
|
|
WDRM_CONNECTOR_HDR_OUTPUT_METADATA)) {
|
|
ret |= connector_add_prop(req, &head->connector,
|
|
WDRM_CONNECTOR_HDR_OUTPUT_METADATA,
|
|
output->hdr_output_metadata_blob_id);
|
|
}
|
|
|
|
ret |= drm_connector_set_max_bpc(&head->connector, output, req);
|
|
}
|
|
|
|
if (ret != 0) {
|
|
weston_log("couldn't set atomic CRTC/connector state\n");
|
|
return ret;
|
|
}
|
|
|
|
wl_list_for_each(plane_state, &state->plane_list, link) {
|
|
struct drm_plane *plane = plane_state->plane;
|
|
const struct pixel_format_info *pinfo = NULL;
|
|
|
|
ret |= plane_add_prop(req, plane, WDRM_PLANE_FB_ID,
|
|
plane_state->fb ? plane_state->fb->fb_id : 0);
|
|
ret |= plane_add_prop(req, plane, WDRM_PLANE_CRTC_ID,
|
|
plane_state->fb ? crtc->crtc_id : 0);
|
|
ret |= plane_add_prop(req, plane, WDRM_PLANE_SRC_X,
|
|
plane_state->src_x);
|
|
ret |= plane_add_prop(req, plane, WDRM_PLANE_SRC_Y,
|
|
plane_state->src_y);
|
|
ret |= plane_add_prop(req, plane, WDRM_PLANE_SRC_W,
|
|
plane_state->src_w);
|
|
ret |= plane_add_prop(req, plane, WDRM_PLANE_SRC_H,
|
|
plane_state->src_h);
|
|
ret |= plane_add_prop(req, plane, WDRM_PLANE_CRTC_X,
|
|
plane_state->dest_x);
|
|
ret |= plane_add_prop(req, plane, WDRM_PLANE_CRTC_Y,
|
|
plane_state->dest_y);
|
|
ret |= plane_add_prop(req, plane, WDRM_PLANE_CRTC_W,
|
|
plane_state->dest_w);
|
|
ret |= plane_add_prop(req, plane, WDRM_PLANE_CRTC_H,
|
|
plane_state->dest_h);
|
|
if (plane->props[WDRM_PLANE_FB_DAMAGE_CLIPS].prop_id != 0)
|
|
ret |= plane_add_prop(req, plane, WDRM_PLANE_FB_DAMAGE_CLIPS,
|
|
plane_state->damage_blob_id);
|
|
|
|
if (plane_state->fb && plane_state->fb->format)
|
|
pinfo = plane_state->fb->format;
|
|
|
|
drm_debug(b, "\t\t\t[PLANE:%lu] FORMAT: %s\n",
|
|
(unsigned long) plane->plane_id,
|
|
pinfo ? pinfo->drm_format_name : "UNKNOWN");
|
|
|
|
if (plane_state->in_fence_fd >= 0) {
|
|
ret |= plane_add_prop(req, plane,
|
|
WDRM_PLANE_IN_FENCE_FD,
|
|
plane_state->in_fence_fd);
|
|
}
|
|
|
|
if (plane->props[WDRM_PLANE_ROTATION].prop_id != 0)
|
|
ret |= plane_add_prop(req, plane, WDRM_PLANE_ROTATION,
|
|
plane_state->rotation);
|
|
|
|
/* do note, that 'invented' zpos values are set as immutable */
|
|
if (plane_state->zpos != DRM_PLANE_ZPOS_INVALID_PLANE &&
|
|
plane_state->plane->zpos_min != plane_state->plane->zpos_max)
|
|
ret |= plane_add_prop(req, plane,
|
|
WDRM_PLANE_ZPOS,
|
|
plane_state->zpos);
|
|
|
|
/*Plane-alpha support */
|
|
if (plane->alpha_max != plane->alpha_min)
|
|
ret |= plane_add_prop(req, plane,
|
|
WDRM_PLANE_ALPHA,
|
|
plane_state->alpha);
|
|
|
|
if (ret != 0) {
|
|
weston_log("couldn't set plane state\n");
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
drm_pending_state_clear_tearing(struct drm_pending_state *pending_state)
|
|
{
|
|
struct drm_output_state *output_state;
|
|
|
|
wl_list_for_each(output_state, &pending_state->output_list, link) {
|
|
if (output_state->output->virtual)
|
|
continue;
|
|
output_state->tear = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper function used only by drm_pending_state_apply, with the same
|
|
* guarantees and constraints as that function.
|
|
*/
|
|
static int
|
|
drm_pending_state_apply_atomic(struct drm_pending_state *pending_state,
|
|
enum drm_state_apply_mode mode)
|
|
{
|
|
struct drm_device *device = pending_state->device;
|
|
struct drm_backend *b = device->backend;
|
|
struct drm_output_state *output_state, *tmp;
|
|
struct drm_plane *plane;
|
|
drmModeAtomicReq *req = drmModeAtomicAlloc();
|
|
uint32_t flags, tear_flag = 0;
|
|
bool may_tear = true;
|
|
int ret = 0;
|
|
|
|
if (!req)
|
|
return -1;
|
|
|
|
switch (mode) {
|
|
case DRM_STATE_APPLY_SYNC:
|
|
flags = 0;
|
|
break;
|
|
case DRM_STATE_APPLY_ASYNC:
|
|
flags = DRM_MODE_PAGE_FLIP_EVENT | DRM_MODE_ATOMIC_NONBLOCK;
|
|
break;
|
|
case DRM_STATE_TEST_ONLY:
|
|
flags = DRM_MODE_ATOMIC_TEST_ONLY;
|
|
break;
|
|
}
|
|
|
|
if (device->state_invalid) {
|
|
struct weston_head *head_base;
|
|
struct drm_head *head;
|
|
struct drm_crtc *crtc;
|
|
uint32_t connector_id;
|
|
int err;
|
|
|
|
drm_debug(b, "\t\t[atomic] previous state invalid; "
|
|
"starting with fresh state\n");
|
|
|
|
/* If we need to reset all our state (e.g. because we've
|
|
* just started, or just been VT-switched in), explicitly
|
|
* disable all the CRTCs and connectors we aren't using. */
|
|
wl_list_for_each(head_base,
|
|
&b->compositor->head_list, compositor_link) {
|
|
struct drm_property_info *info;
|
|
head = to_drm_head(head_base);
|
|
if (!head)
|
|
continue;
|
|
|
|
if (weston_head_is_enabled(head_base))
|
|
continue;
|
|
|
|
connector_id = head->connector.connector_id;
|
|
if (head->connector.device != device)
|
|
continue;
|
|
|
|
drm_debug(b, "\t\t[atomic] disabling inactive head %s\n",
|
|
head_base->name);
|
|
|
|
info = &head->connector.props[WDRM_CONNECTOR_CRTC_ID];
|
|
err = drmModeAtomicAddProperty(req, connector_id,
|
|
info->prop_id, 0);
|
|
drm_debug(b, "\t\t\t[CONN:%lu] %lu (%s) -> 0\n",
|
|
(unsigned long) connector_id,
|
|
(unsigned long) info->prop_id,
|
|
info->name);
|
|
if (err <= 0)
|
|
ret = -1;
|
|
}
|
|
|
|
wl_list_for_each(crtc, &device->crtc_list, link) {
|
|
struct drm_property_info *info;
|
|
drmModeObjectProperties *props;
|
|
uint64_t active;
|
|
|
|
/* Ignore CRTCs that are in use */
|
|
if (crtc->output)
|
|
continue;
|
|
|
|
/* We can't emit a disable on a CRTC that's already
|
|
* off, as the kernel will refuse to generate an event
|
|
* for an off->off state and fail the commit.
|
|
*/
|
|
props = drmModeObjectGetProperties(device->drm.fd,
|
|
crtc->crtc_id,
|
|
DRM_MODE_OBJECT_CRTC);
|
|
if (!props) {
|
|
ret = -1;
|
|
continue;
|
|
}
|
|
|
|
info = &crtc->props_crtc[WDRM_CRTC_ACTIVE];
|
|
active = drm_property_get_value(info, props, 0);
|
|
drmModeFreeObjectProperties(props);
|
|
if (active == 0)
|
|
continue;
|
|
|
|
drm_debug(b, "\t\t[atomic] disabling unused CRTC %lu\n",
|
|
(unsigned long) crtc->crtc_id);
|
|
|
|
ret |= crtc_add_prop(req, crtc, WDRM_CRTC_ACTIVE, 0);
|
|
ret |= crtc_add_prop(req, crtc, WDRM_CRTC_MODE_ID, 0);
|
|
}
|
|
|
|
/* Disable all the planes; planes which are being used will
|
|
* override this state in the output-state application. */
|
|
wl_list_for_each(plane, &device->plane_list, link) {
|
|
drm_debug(b, "\t\t[atomic] starting with plane %lu disabled\n",
|
|
(unsigned long) plane->plane_id);
|
|
plane_add_prop(req, plane, WDRM_PLANE_CRTC_ID, 0);
|
|
plane_add_prop(req, plane, WDRM_PLANE_FB_ID, 0);
|
|
}
|
|
|
|
flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
|
|
}
|
|
|
|
wl_list_for_each(output_state, &pending_state->output_list, link) {
|
|
if (output_state->output->virtual)
|
|
continue;
|
|
if (mode == DRM_STATE_APPLY_SYNC)
|
|
assert(output_state->dpms == WESTON_DPMS_OFF);
|
|
may_tear &= output_state->tear;
|
|
ret |= drm_output_apply_state_atomic(output_state, req, &flags);
|
|
}
|
|
|
|
if (ret != 0) {
|
|
weston_log("atomic: couldn't compile atomic state\n");
|
|
goto out;
|
|
}
|
|
if (may_tear)
|
|
tear_flag = DRM_MODE_PAGE_FLIP_ASYNC;
|
|
|
|
ret = drmModeAtomicCommit(device->drm.fd, req, flags | tear_flag,
|
|
device);
|
|
drm_debug(b, "[atomic] drmModeAtomicCommit\n");
|
|
if (ret != 0 && may_tear && mode == DRM_STATE_TEST_ONLY) {
|
|
/* If we failed trying to set up a tearing commit, try again
|
|
* without tearing. If that succeeds, knock the tearing flag
|
|
* out of our state in case we were testing for a later commit.
|
|
*/
|
|
drm_debug(b, "[atomic] drmModeAtomicCommit (no tear fallback)\n");
|
|
ret = drmModeAtomicCommit(device->drm.fd, req, flags, device);
|
|
if (ret == 0)
|
|
drm_pending_state_clear_tearing(pending_state);
|
|
}
|
|
/* Test commits do not take ownership of the state; return
|
|
* without freeing here. */
|
|
if (mode == DRM_STATE_TEST_ONLY) {
|
|
drmModeAtomicFree(req);
|
|
return ret;
|
|
}
|
|
|
|
if (ret != 0) {
|
|
wl_list_for_each(output_state, &pending_state->output_list, link)
|
|
if (drm_output_get_writeback_state(output_state->output) != DRM_OUTPUT_WB_SCREENSHOT_OFF)
|
|
drm_writeback_fail_screenshot(output_state->output->wb_state,
|
|
"drm: atomic commit failed");
|
|
weston_log("atomic: couldn't commit new state: %s\n",
|
|
strerror(errno));
|
|
goto out;
|
|
}
|
|
|
|
wl_list_for_each_safe(output_state, tmp, &pending_state->output_list,
|
|
link)
|
|
drm_output_assign_state(output_state, mode);
|
|
|
|
device->state_invalid = false;
|
|
|
|
assert(wl_list_empty(&pending_state->output_list));
|
|
|
|
out:
|
|
drmModeAtomicFree(req);
|
|
drm_pending_state_free(pending_state);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Tests a pending state, to see if the kernel will accept the update as
|
|
* constructed.
|
|
*
|
|
* Using atomic modesetting, the kernel performs the same checks as it would
|
|
* on a real commit, returning success or failure without actually modifying
|
|
* the running state. It does not return -EBUSY if there are pending updates
|
|
* in flight, so states may be tested at any point, however this means a
|
|
* state which passed testing may fail on a real commit if the timing is not
|
|
* respected (e.g. committing before the previous commit has completed).
|
|
*
|
|
* Without atomic modesetting, we have no way to check, so we optimistically
|
|
* claim it will work.
|
|
*
|
|
* Unlike drm_pending_state_apply() and drm_pending_state_apply_sync(), this
|
|
* function does _not_ take ownership of pending_state, nor does it clear
|
|
* state_invalid.
|
|
*/
|
|
int
|
|
drm_pending_state_test(struct drm_pending_state *pending_state)
|
|
{
|
|
struct drm_device *device = pending_state->device;
|
|
|
|
if (device->atomic_modeset)
|
|
return drm_pending_state_apply_atomic(pending_state,
|
|
DRM_STATE_TEST_ONLY);
|
|
|
|
/* We have no way to test state before application on the legacy
|
|
* modesetting API, so just claim it succeeded. */
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Applies all of a pending_state asynchronously: the primary entry point for
|
|
* applying KMS state to a device. Updates the state for all outputs in the
|
|
* pending_state, as well as disabling any unclaimed outputs.
|
|
*
|
|
* Unconditionally takes ownership of pending_state, and clears state_invalid.
|
|
*/
|
|
int
|
|
drm_pending_state_apply(struct drm_pending_state *pending_state)
|
|
{
|
|
struct drm_device *device = pending_state->device;
|
|
struct drm_backend *b = device->backend;
|
|
struct drm_output_state *output_state, *tmp;
|
|
struct drm_crtc *crtc;
|
|
|
|
if (wl_list_empty(&pending_state->output_list)) {
|
|
drm_pending_state_free(pending_state);
|
|
return 0;
|
|
}
|
|
|
|
if (device->atomic_modeset)
|
|
return drm_pending_state_apply_atomic(pending_state,
|
|
DRM_STATE_APPLY_ASYNC);
|
|
|
|
if (device->state_invalid) {
|
|
/* If we need to reset all our state (e.g. because we've
|
|
* just started, or just been VT-switched in), explicitly
|
|
* disable all the CRTCs we aren't using. This also disables
|
|
* all connectors on these CRTCs, so we don't need to do that
|
|
* separately with the pre-atomic API. */
|
|
wl_list_for_each(crtc, &device->crtc_list, link) {
|
|
if (crtc->output)
|
|
continue;
|
|
drmModeSetCrtc(device->drm.fd, crtc->crtc_id, 0, 0, 0,
|
|
NULL, 0, NULL);
|
|
}
|
|
}
|
|
|
|
wl_list_for_each_safe(output_state, tmp, &pending_state->output_list,
|
|
link) {
|
|
struct drm_output *output = output_state->output;
|
|
int ret;
|
|
|
|
if (output->virtual) {
|
|
drm_output_assign_state(output_state,
|
|
DRM_STATE_APPLY_ASYNC);
|
|
continue;
|
|
}
|
|
|
|
ret = drm_output_apply_state_legacy(output_state);
|
|
if (ret != 0) {
|
|
weston_log("Couldn't apply state for output %s\n",
|
|
output->base.name);
|
|
weston_output_repaint_failed(&output->base);
|
|
drm_output_state_free(output->state_cur);
|
|
output->state_cur = drm_output_state_alloc(output, NULL);
|
|
device->state_invalid = true;
|
|
if (b->compositor->renderer->type == WESTON_RENDERER_GL) {
|
|
drm_output_fini_egl(output);
|
|
drm_output_init_egl(output, b);
|
|
}
|
|
}
|
|
}
|
|
|
|
device->state_invalid = false;
|
|
|
|
assert(wl_list_empty(&pending_state->output_list));
|
|
|
|
drm_pending_state_free(pending_state);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* The synchronous version of drm_pending_state_apply. May only be used to
|
|
* disable outputs. Does so synchronously: the request is guaranteed to have
|
|
* completed on return, and the output will not be touched afterwards.
|
|
*
|
|
* Unconditionally takes ownership of pending_state, and clears state_invalid.
|
|
*/
|
|
int
|
|
drm_pending_state_apply_sync(struct drm_pending_state *pending_state)
|
|
{
|
|
struct drm_device *device = pending_state->device;
|
|
struct drm_output_state *output_state, *tmp;
|
|
struct drm_crtc *crtc;
|
|
|
|
if (device->atomic_modeset)
|
|
return drm_pending_state_apply_atomic(pending_state,
|
|
DRM_STATE_APPLY_SYNC);
|
|
|
|
if (device->state_invalid) {
|
|
/* If we need to reset all our state (e.g. because we've
|
|
* just started, or just been VT-switched in), explicitly
|
|
* disable all the CRTCs we aren't using. This also disables
|
|
* all connectors on these CRTCs, so we don't need to do that
|
|
* separately with the pre-atomic API. */
|
|
wl_list_for_each(crtc, &device->crtc_list, link) {
|
|
if (crtc->output)
|
|
continue;
|
|
drmModeSetCrtc(device->drm.fd, crtc->crtc_id, 0, 0, 0,
|
|
NULL, 0, NULL);
|
|
}
|
|
}
|
|
|
|
wl_list_for_each_safe(output_state, tmp, &pending_state->output_list,
|
|
link) {
|
|
int ret;
|
|
|
|
assert(output_state->dpms == WESTON_DPMS_OFF);
|
|
ret = drm_output_apply_state_legacy(output_state);
|
|
if (ret != 0) {
|
|
weston_log("Couldn't apply state for output %s\n",
|
|
output_state->output->base.name);
|
|
}
|
|
}
|
|
|
|
device->state_invalid = false;
|
|
|
|
assert(wl_list_empty(&pending_state->output_list));
|
|
|
|
drm_pending_state_free(pending_state);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
drm_output_update_msc(struct drm_output *output, unsigned int seq)
|
|
{
|
|
uint32_t msc_hi = output->base.msc >> 32;
|
|
|
|
if (seq < (output->base.msc & 0xffffffff))
|
|
msc_hi++;
|
|
|
|
output->base.msc = u64_from_u32s(msc_hi, seq);
|
|
}
|
|
|
|
static void
|
|
page_flip_handler(int fd, unsigned int frame,
|
|
unsigned int sec, unsigned int usec, void *data)
|
|
{
|
|
struct drm_output *output = data;
|
|
struct drm_device *device = output->device;
|
|
uint32_t flags = WP_PRESENTATION_FEEDBACK_KIND_VSYNC |
|
|
WP_PRESENTATION_FEEDBACK_KIND_HW_COMPLETION |
|
|
WP_PRESENTATION_FEEDBACK_KIND_HW_CLOCK;
|
|
|
|
drm_output_update_msc(output, frame);
|
|
|
|
assert(!device->atomic_modeset);
|
|
assert(output->page_flip_pending);
|
|
output->page_flip_pending = false;
|
|
|
|
drm_output_update_complete(output, flags, sec, usec);
|
|
}
|
|
|
|
static void
|
|
atomic_flip_handler(int fd, unsigned int frame, unsigned int sec,
|
|
unsigned int usec, unsigned int crtc_id, void *data)
|
|
{
|
|
struct drm_device *device = data;
|
|
struct drm_backend *b = device->backend;
|
|
struct weston_compositor *ec = b->compositor;
|
|
struct drm_crtc *crtc;
|
|
struct drm_output *output;
|
|
struct timespec now;
|
|
uint32_t flags = WP_PRESENTATION_FEEDBACK_KIND_VSYNC |
|
|
WP_PRESENTATION_FEEDBACK_KIND_HW_COMPLETION |
|
|
WP_PRESENTATION_FEEDBACK_KIND_HW_CLOCK;
|
|
|
|
crtc = drm_crtc_find(device, crtc_id);
|
|
assert(crtc);
|
|
|
|
output = crtc->output;
|
|
|
|
/* During the initial modeset, we can disable CRTCs which we don't
|
|
* actually handle during normal operation; this will give us events
|
|
* for unknown outputs. Ignore them. */
|
|
if (!output || !output->base.enabled)
|
|
return;
|
|
|
|
drm_output_update_msc(output, frame);
|
|
|
|
if (output->state_cur->tear) {
|
|
/* When tearing we might not get accurate timestamps from
|
|
* the driver, so just use whatever time it is now.
|
|
* Note: This could actually be after a vblank that occured
|
|
* after entering this function.
|
|
*/
|
|
weston_compositor_read_presentation_clock(ec, &now);
|
|
sec = now.tv_sec;
|
|
usec = now.tv_nsec / 1000;
|
|
}
|
|
|
|
drm_debug(b, "[atomic][CRTC:%u] flip processing started\n", crtc_id);
|
|
assert(device->atomic_modeset);
|
|
assert(output->atomic_complete_pending);
|
|
output->atomic_complete_pending = false;
|
|
|
|
drm_output_update_complete(output, flags, sec, usec);
|
|
drm_debug(b, "[atomic][CRTC:%u] flip processing completed\n", crtc_id);
|
|
}
|
|
|
|
int
|
|
on_drm_input(int fd, uint32_t mask, void *data)
|
|
{
|
|
struct drm_device *device = data;
|
|
struct drm_writeback_state *state;
|
|
struct drm_crtc *crtc;
|
|
bool wait_wb_completion = false;
|
|
drmEventContext evctx;
|
|
|
|
/* If we have a pending writeback job for this output, we can't continue
|
|
* with the repaint loop. The KMS UAPI docs says that we need to wait
|
|
* until the writeback is over before we send a new atomic commit that
|
|
* uses the KMS objects (CRTC, planes, etc) in use by the writeback. */
|
|
wl_list_for_each(crtc, &device->crtc_list, link) {
|
|
state = crtc->output ? crtc->output->wb_state : NULL;
|
|
if (state && drm_writeback_should_wait_completion(state))
|
|
wait_wb_completion = true;
|
|
}
|
|
if (wait_wb_completion)
|
|
return 1;
|
|
|
|
memset(&evctx, 0, sizeof evctx);
|
|
evctx.version = 3;
|
|
if (device->atomic_modeset)
|
|
evctx.page_flip_handler2 = atomic_flip_handler;
|
|
else
|
|
evctx.page_flip_handler = page_flip_handler;
|
|
drmHandleEvent(fd, &evctx);
|
|
|
|
return 1;
|
|
}
|
|
|
|
int
|
|
init_kms_caps(struct drm_device *device)
|
|
{
|
|
struct drm_backend *b = device->backend;
|
|
struct weston_compositor *compositor = b->compositor;
|
|
uint64_t cap;
|
|
int ret;
|
|
|
|
weston_log("using %s\n", device->drm.filename);
|
|
|
|
ret = drmGetCap(device->drm.fd, DRM_CAP_TIMESTAMP_MONOTONIC, &cap);
|
|
if (ret != 0 || cap != 1) {
|
|
weston_log("Error: kernel DRM KMS does not support DRM_CAP_TIMESTAMP_MONOTONIC.\n");
|
|
return -1;
|
|
}
|
|
|
|
if (weston_compositor_set_presentation_clock(compositor, CLOCK_MONOTONIC) < 0) {
|
|
weston_log("Error: failed to set presentation clock to CLOCK_MONOTONIC.\n");
|
|
return -1;
|
|
}
|
|
|
|
ret = drmGetCap(device->drm.fd, DRM_CAP_CURSOR_WIDTH, &cap);
|
|
if (ret == 0)
|
|
device->cursor_width = cap;
|
|
else
|
|
device->cursor_width = 64;
|
|
|
|
ret = drmGetCap(device->drm.fd, DRM_CAP_CURSOR_HEIGHT, &cap);
|
|
if (ret == 0)
|
|
device->cursor_height = cap;
|
|
else
|
|
device->cursor_height = 64;
|
|
|
|
ret = drmSetClientCap(device->drm.fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
|
|
if (ret) {
|
|
weston_log("Error: drm card doesn't support universal planes!\n");
|
|
return -1;
|
|
}
|
|
|
|
if (!getenv("WESTON_DISABLE_ATOMIC")) {
|
|
ret = drmGetCap(device->drm.fd, DRM_CAP_CRTC_IN_VBLANK_EVENT, &cap);
|
|
if (ret != 0)
|
|
cap = 0;
|
|
ret = drmSetClientCap(device->drm.fd, DRM_CLIENT_CAP_ATOMIC, 1);
|
|
device->atomic_modeset = ((ret == 0) && (cap == 1));
|
|
}
|
|
weston_log("DRM: %s atomic modesetting\n",
|
|
device->atomic_modeset ? "supports" : "does not support");
|
|
|
|
if (!getenv("WESTON_DISABLE_GBM_MODIFIERS")) {
|
|
ret = drmGetCap(device->drm.fd, DRM_CAP_ADDFB2_MODIFIERS, &cap);
|
|
if (ret == 0)
|
|
device->fb_modifiers = cap;
|
|
}
|
|
weston_log("DRM: %s GBM modifiers\n",
|
|
device->fb_modifiers ? "supports" : "does not support");
|
|
|
|
drmSetClientCap(device->drm.fd, DRM_CLIENT_CAP_WRITEBACK_CONNECTORS, 1);
|
|
|
|
#if 0
|
|
/* FIXME: DRM_CAP_ATOMIC_ASYNC_PAGE_FLIP isn't merged into mainline so
|
|
* we can't really use it at this point. Until then, make it so we
|
|
* don't support it. After it gets merged, we can flip this back such
|
|
* that we don't need to revert the entire tearing work, and we can
|
|
* still get it all back, when the capability is actually available in
|
|
* the kernel. */
|
|
ret = drmGetCap(device->drm.fd, DRM_CAP_ATOMIC_ASYNC_PAGE_FLIP, &cap);
|
|
if (ret != 0)
|
|
cap = 0;
|
|
#endif
|
|
device->tearing_supported = 0;
|
|
weston_log("DRM: does not support async page flipping\n");
|
|
|
|
/*
|
|
* KMS support for hardware planes cannot properly synchronize
|
|
* without nuclear page flip. Without nuclear/atomic, hw plane
|
|
* and cursor plane updates would either tear or cause extra
|
|
* waits for vblanks which means dropping the compositor framerate
|
|
* to a fraction. For cursors, it's not so bad, so they are
|
|
* enabled.
|
|
*/
|
|
if (!device->atomic_modeset || getenv("WESTON_FORCE_RENDERER"))
|
|
device->sprites_are_broken = true;
|
|
|
|
ret = drmSetClientCap(device->drm.fd, DRM_CLIENT_CAP_ASPECT_RATIO, 1);
|
|
device->aspect_ratio_supported = (ret == 0);
|
|
weston_log("DRM: %s picture aspect ratio\n",
|
|
device->aspect_ratio_supported ? "supports" : "does not support");
|
|
|
|
return 0;
|
|
}
|