2020-08-02 22:22:19 +00:00
|
|
|
/*
|
|
|
|
KWin - the KDE window manager
|
|
|
|
This file is part of the KDE project.
|
2016-08-31 12:00:31 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
SPDX-FileCopyrightText: 2016 Roman Gilg <subdiff@gmail.com>
|
2016-08-31 12:00:31 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
*/
|
2016-08-31 12:00:31 +00:00
|
|
|
#include "drm_object_plane.h"
|
|
|
|
#include "drm_buffer.h"
|
2021-04-01 11:15:42 +00:00
|
|
|
#include "drm_gpu.h"
|
2016-08-31 12:00:31 +00:00
|
|
|
#include "drm_pointer.h"
|
|
|
|
#include "logging.h"
|
2021-07-31 13:32:50 +00:00
|
|
|
#include "config-kwin.h"
|
|
|
|
|
2021-08-26 16:36:52 +00:00
|
|
|
#include <drm_fourcc.h>
|
2016-08-31 12:00:31 +00:00
|
|
|
|
|
|
|
namespace KWin
|
|
|
|
{
|
|
|
|
|
2021-04-01 11:21:37 +00:00
|
|
|
DrmPlane::DrmPlane(DrmGpu *gpu, uint32_t planeId)
|
2021-06-03 13:50:37 +00:00
|
|
|
: DrmObject(gpu, planeId, {
|
2021-08-27 16:56:05 +00:00
|
|
|
PropertyDefinition(QByteArrayLiteral("type"), Requirement::Required, {
|
2021-03-10 21:04:32 +00:00
|
|
|
QByteArrayLiteral("Overlay"),
|
|
|
|
QByteArrayLiteral("Primary"),
|
|
|
|
QByteArrayLiteral("Cursor")}),
|
2021-08-27 16:56:05 +00:00
|
|
|
PropertyDefinition(QByteArrayLiteral("SRC_X"), Requirement::Required),
|
|
|
|
PropertyDefinition(QByteArrayLiteral("SRC_Y"), Requirement::Required),
|
|
|
|
PropertyDefinition(QByteArrayLiteral("SRC_W"), Requirement::Required),
|
|
|
|
PropertyDefinition(QByteArrayLiteral("SRC_H"), Requirement::Required),
|
|
|
|
PropertyDefinition(QByteArrayLiteral("CRTC_X"), Requirement::Required),
|
|
|
|
PropertyDefinition(QByteArrayLiteral("CRTC_Y"), Requirement::Required),
|
|
|
|
PropertyDefinition(QByteArrayLiteral("CRTC_W"), Requirement::Required),
|
|
|
|
PropertyDefinition(QByteArrayLiteral("CRTC_H"), Requirement::Required),
|
|
|
|
PropertyDefinition(QByteArrayLiteral("FB_ID"), Requirement::Required),
|
|
|
|
PropertyDefinition(QByteArrayLiteral("CRTC_ID"), Requirement::Required),
|
|
|
|
PropertyDefinition(QByteArrayLiteral("rotation"), Requirement::Optional, {
|
2021-03-10 21:04:32 +00:00
|
|
|
QByteArrayLiteral("rotate-0"),
|
|
|
|
QByteArrayLiteral("rotate-90"),
|
|
|
|
QByteArrayLiteral("rotate-180"),
|
|
|
|
QByteArrayLiteral("rotate-270"),
|
|
|
|
QByteArrayLiteral("reflect-x"),
|
|
|
|
QByteArrayLiteral("reflect-y")}),
|
2021-08-27 16:56:05 +00:00
|
|
|
PropertyDefinition(QByteArrayLiteral("IN_FORMATS"), Requirement::Optional),
|
2021-06-03 13:50:37 +00:00
|
|
|
}, DRM_MODE_OBJECT_PLANE)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
bool DrmPlane::init()
|
|
|
|
{
|
|
|
|
DrmScopedPointer<drmModePlane> p(drmModeGetPlane(gpu()->fd(), id()));
|
|
|
|
|
|
|
|
if (!p) {
|
|
|
|
qCWarning(KWIN_DRM) << "Failed to get kernel plane" << id();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
m_possibleCrtcs = p->possible_crtcs;
|
|
|
|
|
|
|
|
bool success = initProps();
|
2021-03-10 21:04:32 +00:00
|
|
|
if (success) {
|
|
|
|
m_supportedTransformations = Transformations();
|
|
|
|
auto checkSupport = [this] (uint64_t value, Transformation t) {
|
|
|
|
if (propHasEnum(PropertyIndex::Rotation, value)) {
|
|
|
|
m_supportedTransformations |= t;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
checkSupport(0, Transformation::Rotate0);
|
|
|
|
checkSupport(1, Transformation::Rotate90);
|
|
|
|
checkSupport(2, Transformation::Rotate180);
|
|
|
|
checkSupport(3, Transformation::Rotate270);
|
|
|
|
checkSupport(4, Transformation::ReflectX);
|
|
|
|
checkSupport(5, Transformation::ReflectY);
|
2021-07-31 13:32:50 +00:00
|
|
|
|
|
|
|
// read formats from blob if available and if modifiers are supported, and from the plane object if not
|
2021-10-14 15:25:13 +00:00
|
|
|
bool modifiersEnvSet = false;
|
|
|
|
bool modifiersEnv = qEnvironmentVariableIntValue("KWIN_DRM_USE_MODIFIERS", &modifiersEnvSet) != 0;
|
|
|
|
bool allowModifiers = (gpu()->isNVidia() && !modifiersEnvSet) || (modifiersEnvSet && modifiersEnv);
|
|
|
|
if (auto formatProp = getProp(PropertyIndex::In_Formats); formatProp && gpu()->addFB2ModifiersSupported() && allowModifiers) {
|
2021-09-27 18:43:26 +00:00
|
|
|
DrmScopedPointer<drmModePropertyBlobRes> propertyBlob(drmModeGetPropertyBlob(gpu()->fd(), formatProp->current()));
|
|
|
|
if (propertyBlob && propertyBlob->data) {
|
|
|
|
auto blob = static_cast<drm_format_modifier_blob*>(propertyBlob->data);
|
|
|
|
auto modifiers = reinterpret_cast<drm_format_modifier*>(reinterpret_cast<uint8_t*>(blob) + blob->modifiers_offset);
|
|
|
|
uint32_t *formatarr = reinterpret_cast<uint32_t*>(reinterpret_cast<uint8_t*>(blob) + blob->formats_offset);
|
2021-07-31 13:32:50 +00:00
|
|
|
|
2021-09-27 18:43:26 +00:00
|
|
|
for (uint32_t f = 0; f < blob->count_formats; f++) {
|
|
|
|
auto format = formatarr[f];
|
|
|
|
QVector<uint64_t> mods;
|
|
|
|
for (uint32_t m = 0; m < blob->count_modifiers; m++) {
|
|
|
|
auto modifier = &modifiers[m];
|
|
|
|
// The modifier advertisement blob is partitioned into groups of 64 formats
|
|
|
|
if (m < modifier->offset || m > modifier->offset + 63) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!(modifier->formats & (1 << (f - modifier->offset)))) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
mods << modifier->modifier;
|
2021-07-31 13:32:50 +00:00
|
|
|
}
|
2021-09-27 18:43:26 +00:00
|
|
|
m_supportedFormats.insert(format, mods);
|
2021-07-31 13:32:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (uint32_t i = 0; i < p->count_formats; i++) {
|
|
|
|
m_supportedFormats.insert(p->formats[i], {});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (m_supportedFormats.isEmpty()) {
|
|
|
|
qCWarning(KWIN_DRM) << "Driver doesn't advertise any formats for this plane. Falling back to XRGB8888 and ARGB8888 without modifiers";
|
2021-08-26 16:36:52 +00:00
|
|
|
m_supportedFormats.insert(DRM_FORMAT_XRGB8888, {});
|
|
|
|
m_supportedFormats.insert(DRM_FORMAT_ARGB8888, {});
|
2021-07-31 13:32:50 +00:00
|
|
|
}
|
2016-08-31 12:00:31 +00:00
|
|
|
}
|
2021-03-10 21:04:32 +00:00
|
|
|
return success;
|
2016-08-31 12:00:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
DrmPlane::TypeIndex DrmPlane::type()
|
|
|
|
{
|
2021-08-31 01:40:18 +00:00
|
|
|
const auto &prop = getProp(PropertyIndex::Type);
|
|
|
|
return prop->enumForValue<DrmPlane::TypeIndex>(prop->current());
|
2016-08-31 12:00:31 +00:00
|
|
|
}
|
|
|
|
|
2021-03-22 14:46:09 +00:00
|
|
|
void DrmPlane::setNext(const QSharedPointer<DrmBuffer> &b)
|
2017-11-10 19:38:33 +00:00
|
|
|
{
|
2017-05-09 19:29:10 +00:00
|
|
|
m_next = b;
|
2016-08-31 12:00:31 +00:00
|
|
|
}
|
|
|
|
|
2021-05-25 22:05:17 +00:00
|
|
|
bool DrmPlane::setTransformation(Transformations t)
|
2017-10-31 17:08:36 +00:00
|
|
|
{
|
2021-05-25 22:05:17 +00:00
|
|
|
if (m_supportedTransformations & t) {
|
|
|
|
return setPending(PropertyIndex::Rotation, t);
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
2017-10-31 17:08:36 +00:00
|
|
|
}
|
|
|
|
|
2017-11-01 18:21:08 +00:00
|
|
|
DrmPlane::Transformations DrmPlane::transformation()
|
|
|
|
{
|
2021-05-25 22:05:17 +00:00
|
|
|
if (auto property = getProp(PropertyIndex::Rotation)) {
|
|
|
|
return Transformations(static_cast<uint32_t>(property->pending()));
|
2017-11-10 19:38:33 +00:00
|
|
|
}
|
|
|
|
return Transformations(Transformation::Rotate0);
|
2017-11-01 18:21:08 +00:00
|
|
|
}
|
|
|
|
|
2017-05-09 19:29:10 +00:00
|
|
|
void DrmPlane::flipBuffer()
|
|
|
|
{
|
2021-03-20 18:18:52 +00:00
|
|
|
m_current = m_next;
|
|
|
|
m_next = nullptr;
|
2016-08-31 12:00:31 +00:00
|
|
|
}
|
|
|
|
|
2021-05-25 22:05:17 +00:00
|
|
|
void DrmPlane::set(const QPoint &srcPos, const QSize &srcSize, const QPoint &dstPos, const QSize &dstSize)
|
|
|
|
{
|
|
|
|
// Src* are in 16.16 fixed point format
|
|
|
|
setPending(PropertyIndex::SrcX, srcPos.x() << 16);
|
|
|
|
setPending(PropertyIndex::SrcY, srcPos.y() << 16);
|
|
|
|
setPending(PropertyIndex::SrcW, srcSize.width() << 16);
|
|
|
|
setPending(PropertyIndex::SrcH, srcSize.height() << 16);
|
|
|
|
setPending(PropertyIndex::CrtcX, dstPos.x());
|
|
|
|
setPending(PropertyIndex::CrtcY, dstPos.y());
|
|
|
|
setPending(PropertyIndex::CrtcW, dstSize.width());
|
|
|
|
setPending(PropertyIndex::CrtcH, dstSize.height());
|
|
|
|
}
|
|
|
|
|
|
|
|
void DrmPlane::setBuffer(DrmBuffer *buffer)
|
|
|
|
{
|
|
|
|
setPending(PropertyIndex::FbId, buffer ? buffer->bufferId() : 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool DrmPlane::needsModeset() const
|
|
|
|
{
|
2021-07-12 12:28:38 +00:00
|
|
|
auto rotation = getProp(PropertyIndex::Rotation);
|
|
|
|
if (rotation && rotation->needsCommit()) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return getProp(PropertyIndex::CrtcId)->needsCommit();
|
2021-05-25 22:05:17 +00:00
|
|
|
}
|
|
|
|
|
2021-09-22 11:26:19 +00:00
|
|
|
bool DrmPlane::isCrtcSupported(int pipeIndex) const
|
|
|
|
{
|
|
|
|
return (m_possibleCrtcs & (1 << pipeIndex));
|
|
|
|
}
|
|
|
|
|
|
|
|
QMap<uint32_t, QVector<uint64_t>> DrmPlane::formats() const
|
|
|
|
{
|
|
|
|
return m_supportedFormats;
|
|
|
|
}
|
|
|
|
|
|
|
|
QSharedPointer<DrmBuffer> DrmPlane::current() const
|
|
|
|
{
|
|
|
|
return m_current;
|
|
|
|
}
|
|
|
|
|
|
|
|
QSharedPointer<DrmBuffer> DrmPlane::next() const
|
|
|
|
{
|
|
|
|
return m_next;
|
|
|
|
}
|
|
|
|
|
|
|
|
void DrmPlane::setCurrent(const QSharedPointer<DrmBuffer> &b)
|
|
|
|
{
|
|
|
|
m_current = b;
|
|
|
|
}
|
|
|
|
|
|
|
|
DrmPlane::Transformations DrmPlane::supportedTransformations() const
|
|
|
|
{
|
|
|
|
return m_supportedTransformations;
|
|
|
|
}
|
|
|
|
|
2016-08-31 12:00:31 +00:00
|
|
|
}
|