yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/src/backends/drm/drm_pipeline.cpp

622 lines
21 KiB
C++
Raw Normal View History

platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
/*
KWin - the KDE window manager
This file is part of the KDE project.
SPDX-FileCopyrightText: 2021 Xaver Hugl <xaver.hugl@gmail.com>
SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "drm_pipeline.h"
#include <errno.h>
#include "logging.h"
#include "drm_gpu.h"
#include "drm_object_connector.h"
#include "drm_object_crtc.h"
#include "drm_object_plane.h"
#include "drm_buffer.h"
#include "cursor.h"
#include "session.h"
platforms/drm: introduce virtual outputs When the last output gets disconnected, create a virtual output as a placeholder until we have access to a physical output again. While this placecholder never gets rendered to, with virtual outputs in general that is possible (with gbm and qpainter atm) and can be done for future use cases like wireless displays. CCBUG: 420160 CCBUG: 438839
2021-07-26 23:11:50 +00:00
#include "drm_output.h"
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
#include "drm_backend.h"
#if HAVE_GBM
#include <gbm.h>
#include "egl_gbm_backend.h"
#include "drm_buffer_gbm.h"
#endif
platforms/drm: fix legacy mode CCBUG: 441253
2021-08-26 16:17:31 +00:00
#include <drm_fourcc.h>
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
namespace KWin
{
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
DrmPipeline::DrmPipeline(DrmConnector *conn)
platforms/drm: rename user data in DrmPipeline to output
2021-08-07 22:03:09 +00:00
: m_output(nullptr)
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
, m_connector(conn)
{
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
if (!gpu()->atomicModeSetting()) {
platforms/drm: simplify format stuff a bit
2021-09-16 10:48:38 +00:00
m_formats.insert(DRM_FORMAT_XRGB8888, {});
m_formats.insert(DRM_FORMAT_ARGB8888, {});
Test DrmPipelines for outputs Not all combinations of connectors, crtcs and planes will work on all hardware, so we need to test the pipelines before using them. BUG: 433107 CCBUG: 435265
2021-08-07 18:06:40 +00:00
}
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
DrmPipeline::~DrmPipeline()
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
{
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
m_output = nullptr;
if (m_pageflipPending && m_current.crtc) {
pageFlipped({});
}
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
bool DrmPipeline::present(const QSharedPointer<DrmBuffer> &buffer)
{
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
Q_ASSERT(pending.crtc);
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
if (!buffer) {
if (m_output) {
m_output->presentFailed();
}
return false;
}
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
m_primaryBuffer = buffer;
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
if (gpu()->useEglStreams() && gpu()->eglBackend() != nullptr && gpu() == gpu()->platform()->primaryGpu()) {
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
// EglStreamBackend queues normal page flips through EGL,
// modesets etc are performed through DRM-KMS
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
if (!m_connector->needsCommit() && !pending.crtc->needsCommit()) {
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
return true;
}
}
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
bool directScanout = false;
#if HAVE_GBM
// with direct scanout disallow modesets, calling presentFailed() and logging warnings
if (auto buf = dynamic_cast<DrmGbmBuffer*>(buffer.data()); buf && buf->clientBuffer()) {
directScanout = true;
}
#endif
if (gpu()->needsModeset()) {
if (directScanout) {
return false;
}
m_modesetPresentPending = true;
return gpu()->maybeModeset();
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
if (gpu()->atomicModeSetting()) {
if (!commitPipelines({this}, CommitMode::Commit)) {
platforms/drm: update properties on VT switch and failing commits
2021-06-03 13:50:37 +00:00
// update properties and try again
updateProperties();
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
if (!commitPipelines({this}, CommitMode::Commit)) {
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
if (directScanout) {
return false;
}
platforms/drm: update properties on VT switch and failing commits
2021-06-03 13:50:37 +00:00
qCWarning(KWIN_DRM) << "Atomic present failed!" << strerror(errno);
printDebugInfo();
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
if (m_output) {
m_output->presentFailed();
}
platforms/drm: update properties on VT switch and failing commits
2021-06-03 13:50:37 +00:00
return false;
}
}
} else {
if (!presentLegacy()) {
qCWarning(KWIN_DRM) << "Present failed!" << strerror(errno);
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
if (m_output) {
m_output->presentFailed();
}
platforms/drm: update properties on VT switch and failing commits
2021-06-03 13:50:37 +00:00
return false;
}
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
platforms/drm: update properties on VT switch and failing commits
2021-06-03 13:50:37 +00:00
return true;
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
platforms/drm: disable unused resources on modesets When we switch CRTCs it can happen that a CRTC would stay enabled yet has no connectors anymore. In this case the kernel may reject our atomic commit, which would cause the modeset to fail. To counteract that, properly disable unused drm objects
2021-10-08 09:22:02 +00:00
bool DrmPipeline::commitPipelines(const QVector<DrmPipeline*> &pipelines, CommitMode mode, const QVector<DrmObject*> &unusedObjects)
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
{
Test DrmPipelines for outputs Not all combinations of connectors, crtcs and planes will work on all hardware, so we need to test the pipelines before using them. BUG: 433107 CCBUG: 435265
2021-08-07 18:06:40 +00:00
Q_ASSERT(!pipelines.isEmpty());
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
if (pipelines[0]->gpu()->atomicModeSetting()) {
Test DrmPipelines for outputs Not all combinations of connectors, crtcs and planes will work on all hardware, so we need to test the pipelines before using them. BUG: 433107 CCBUG: 435265
2021-08-07 18:06:40 +00:00
drmModeAtomicReq *req = drmModeAtomicAlloc();
if (!req) {
qCDebug(KWIN_DRM) << "Failed to allocate drmModeAtomicReq!" << strerror(errno);
return false;
}
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
uint32_t flags = 0;
platforms/drm: improve logging a bit Only print the flags once for all pipelines and include changed unused objects as well.
2021-10-20 08:43:35 +00:00
const auto &failed = [pipelines, req, mode, &flags, unusedObjects](){
platforms/drm: improve warning messages in DrmPipeline
2021-09-09 10:52:04 +00:00
drmModeAtomicFree(req);
platforms/drm: improve logging a bit Only print the flags once for all pipelines and include changed unused objects as well.
2021-10-20 08:43:35 +00:00
printFlags(flags);
platforms/drm: improve warning messages in DrmPipeline
2021-09-09 10:52:04 +00:00
for (const auto &pipeline : pipelines) {
pipeline->printDebugInfo();
if (pipeline->m_oldTestBuffer) {
pipeline->m_primaryBuffer = pipeline->m_oldTestBuffer;
pipeline->m_oldTestBuffer = nullptr;
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
pipeline->m_connector->rollbackPending();
if (pipeline->pending.crtc) {
pipeline->pending.crtc->rollbackPending();
pipeline->pending.crtc->primaryPlane()->rollbackPending();
platforms/drm: improve warning messages in DrmPipeline
2021-09-09 10:52:04 +00:00
}
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
if (mode != CommitMode::Test && pipeline->activePending() && pipeline->output()) {
pipeline->m_modesetPresentPending = false;
pipeline->output()->presentFailed();
}
platforms/drm: improve warning messages in DrmPipeline
2021-09-09 10:52:04 +00:00
}
platforms/drm: disable unused resources on modesets When we switch CRTCs it can happen that a CRTC would stay enabled yet has no connectors anymore. In this case the kernel may reject our atomic commit, which would cause the modeset to fail. To counteract that, properly disable unused drm objects
2021-10-08 09:22:02 +00:00
for (const auto &obj : unusedObjects) {
platforms/drm: improve logging a bit Only print the flags once for all pipelines and include changed unused objects as well.
2021-10-20 08:43:35 +00:00
printProps(obj, PrintMode::OnlyChanged);
platforms/drm: disable unused resources on modesets When we switch CRTCs it can happen that a CRTC would stay enabled yet has no connectors anymore. In this case the kernel may reject our atomic commit, which would cause the modeset to fail. To counteract that, properly disable unused drm objects
2021-10-08 09:22:02 +00:00
obj->rollbackPending();
}
platforms/drm: improve warning messages in DrmPipeline
2021-09-09 10:52:04 +00:00
return false;
};
Test DrmPipelines for outputs Not all combinations of connectors, crtcs and planes will work on all hardware, so we need to test the pipelines before using them. BUG: 433107 CCBUG: 435265
2021-08-07 18:06:40 +00:00
for (const auto &pipeline : pipelines) {
platforms/drm: improve warning messages in DrmPipeline
2021-09-09 10:52:04 +00:00
if (!pipeline->checkTestBuffer()) {
qCWarning(KWIN_DRM) << "Checking test buffer failed for" << mode;
return failed();
}
if (!pipeline->populateAtomicValues(req, flags)) {
qCWarning(KWIN_DRM) << "Populating atomic values failed for" << mode;
return failed();
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
}
platforms/drm: disable unused resources on modesets When we switch CRTCs it can happen that a CRTC would stay enabled yet has no connectors anymore. In this case the kernel may reject our atomic commit, which would cause the modeset to fail. To counteract that, properly disable unused drm objects
2021-10-08 09:22:02 +00:00
for (const auto &unused : unusedObjects) {
unused->disable();
if (unused->needsModeset()) {
flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
}
if (!unused->atomicPopulate(req)) {
qCWarning(KWIN_DRM) << "Populating atomic values failed for unused resource" << unused;
return failed();
}
}
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
bool modeset = flags & DRM_MODE_ATOMIC_ALLOW_MODESET;
Q_ASSERT(!modeset || mode != CommitMode::Commit);
if (modeset) {
// The kernel fails commits with DRM_MODE_PAGE_FLIP_EVENT when a crtc is disabled in the commit
// and already was disabled before, to work around some quirks in old userspace.
// Instead of using DRM_MODE_PAGE_FLIP_EVENT | DRM_MODE_ATOMIC_NONBLOCK, do the modeset in a blocking
// fashion without page flip events and directly call the pageFlipped method afterwards
flags = flags & (~DRM_MODE_PAGE_FLIP_EVENT);
} else {
flags |= DRM_MODE_ATOMIC_NONBLOCK;
}
if (drmModeAtomicCommit(pipelines[0]->gpu()->fd(), req, (flags & (~DRM_MODE_PAGE_FLIP_EVENT)) | DRM_MODE_ATOMIC_TEST_ONLY, nullptr) != 0) {
platforms/drm: improve warning messages in DrmPipeline
2021-09-09 10:52:04 +00:00
qCWarning(KWIN_DRM) << "Atomic test for" << mode << "failed!" << strerror(errno);
return failed();
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
if (mode != CommitMode::Test && drmModeAtomicCommit(pipelines[0]->gpu()->fd(), req, flags, nullptr) != 0) {
platforms/drm: improve warning messages in DrmPipeline
2021-09-09 10:52:04 +00:00
qCWarning(KWIN_DRM) << "Atomic commit failed! This should never happen!" << strerror(errno);
return failed();
}
for (const auto &pipeline : pipelines) {
pipeline->m_oldTestBuffer = nullptr;
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
pipeline->m_connector->commitPending();
if (pipeline->pending.crtc) {
pipeline->pending.crtc->commitPending();
pipeline->pending.crtc->primaryPlane()->commitPending();
platforms/drm: disable unused resources on modesets When we switch CRTCs it can happen that a CRTC would stay enabled yet has no connectors anymore. In this case the kernel may reject our atomic commit, which would cause the modeset to fail. To counteract that, properly disable unused drm objects
2021-10-08 09:22:02 +00:00
pipeline->pending.crtc->cursorPlane()->commitPending();
Test DrmPipelines for outputs Not all combinations of connectors, crtcs and planes will work on all hardware, so we need to test the pipelines before using them. BUG: 433107 CCBUG: 435265
2021-08-07 18:06:40 +00:00
}
platforms/drm: improve warning messages in DrmPipeline
2021-09-09 10:52:04 +00:00
if (mode != CommitMode::Test) {
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
pipeline->m_modesetPresentPending = false;
pipeline->m_pageflipPending = true;
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
pipeline->m_connector->commit();
if (pipeline->pending.crtc) {
pipeline->pending.crtc->primaryPlane()->setNext(pipeline->m_primaryBuffer);
pipeline->pending.crtc->commit();
pipeline->pending.crtc->primaryPlane()->commit();
platforms/drm: disable unused resources on modesets When we switch CRTCs it can happen that a CRTC would stay enabled yet has no connectors anymore. In this case the kernel may reject our atomic commit, which would cause the modeset to fail. To counteract that, properly disable unused drm objects
2021-10-08 09:22:02 +00:00
pipeline->pending.crtc->cursorPlane()->commit();
Test DrmPipelines for outputs Not all combinations of connectors, crtcs and planes will work on all hardware, so we need to test the pipelines before using them. BUG: 433107 CCBUG: 435265
2021-08-07 18:06:40 +00:00
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
pipeline->m_current = pipeline->pending;
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
if (modeset && pipeline->activePending()) {
pipeline->pageFlipped(std::chrono::steady_clock::now().time_since_epoch());
}
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
}
platforms/drm: disable unused resources on modesets When we switch CRTCs it can happen that a CRTC would stay enabled yet has no connectors anymore. In this case the kernel may reject our atomic commit, which would cause the modeset to fail. To counteract that, properly disable unused drm objects
2021-10-08 09:22:02 +00:00
for (const auto &obj : unusedObjects) {
obj->commitPending();
if (mode != CommitMode::Test) {
obj->commit();
}
}
Test DrmPipelines for outputs Not all combinations of connectors, crtcs and planes will work on all hardware, so we need to test the pipelines before using them. BUG: 433107 CCBUG: 435265
2021-08-07 18:06:40 +00:00
drmModeAtomicFree(req);
platforms/drm: improve warning messages in DrmPipeline
2021-09-09 10:52:04 +00:00
return true;
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
} else {
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
bool failure = false;
Test DrmPipelines for outputs Not all combinations of connectors, crtcs and planes will work on all hardware, so we need to test the pipelines before using them. BUG: 433107 CCBUG: 435265
2021-08-07 18:06:40 +00:00
for (const auto &pipeline : pipelines) {
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
if (!pipeline->applyPendingChangesLegacy()) {
failure = true;
break;
Test DrmPipelines for outputs Not all combinations of connectors, crtcs and planes will work on all hardware, so we need to test the pipelines before using them. BUG: 433107 CCBUG: 435265
2021-08-07 18:06:40 +00:00
}
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
if (failure) {
// at least try to revert the config
for (const auto &pipeline : pipelines) {
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
pipeline->revertPendingChanges();
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
pipeline->applyPendingChangesLegacy();
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
if (mode == CommitMode::CommitModeset && pipeline->output() && pipeline->activePending()) {
pipeline->output()->presentFailed();
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
}
return false;
} else {
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
for (const auto &pipeline : pipelines) {
pipeline->applyPendingChanges();
pipeline->m_current = pipeline->pending;
if (mode == CommitMode::CommitModeset && mode != CommitMode::Test && pipeline->activePending()) {
pipeline->pageFlipped(std::chrono::steady_clock::now().time_since_epoch());
}
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
return true;
}
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
}
bool DrmPipeline::populateAtomicValues(drmModeAtomicReq *req, uint32_t &flags)
{
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
if (needsModeset()) {
prepareModeset();
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
}
bool usesEglStreams = gpu()->useEglStreams() && gpu()->eglBackend() != nullptr && gpu() == gpu()->platform()->primaryGpu();
if (!usesEglStreams && activePending()) {
flags |= DRM_MODE_PAGE_FLIP_EVENT;
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
if (pending.crtc) {
auto modeSize = m_connector->modes()[pending.modeIndex].size;
pending.crtc->primaryPlane()->set(QPoint(0, 0), m_primaryBuffer ? m_primaryBuffer->size() : modeSize, QPoint(0, 0), modeSize);
pending.crtc->primaryPlane()->setBuffer(activePending() ? m_primaryBuffer.get() : nullptr);
pending.crtc->setPending(DrmCrtc::PropertyIndex::VrrEnabled, pending.syncMode == RenderLoopPrivate::SyncMode::Adaptive);
if (pending.gamma != m_current.gamma) {
if (pending.gamma) {
pending.crtc->setPendingBlob(DrmCrtc::PropertyIndex::Gamma_LUT, pending.gamma->atomicLut, pending.gamma->size * sizeof(drm_color_lut));
} else {
pending.crtc->setPendingBlob(DrmCrtc::PropertyIndex::Gamma_LUT, nullptr, 256 * sizeof(drm_color_lut));
}
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
return m_connector->atomicPopulate(req) && (!pending.crtc || (pending.crtc->atomicPopulate(req) && pending.crtc->primaryPlane()->atomicPopulate(req)));
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
bool DrmPipeline::presentLegacy()
{
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
if ((!pending.crtc->current() || pending.crtc->current()->needsModeChange(m_primaryBuffer.get())) && !legacyModeset()) {
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
return false;
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
QVector<DrmPipeline*> *userData = new QVector<DrmPipeline*>();
*userData << this;
if (drmModePageFlip(gpu()->fd(), pending.crtc->id(), m_primaryBuffer ? m_primaryBuffer->bufferId() : 0, DRM_MODE_PAGE_FLIP_EVENT, userData) != 0) {
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
qCWarning(KWIN_DRM) << "Page flip failed:" << strerror(errno) << m_primaryBuffer;
return false;
}
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
m_pageflipPending = true;
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
pending.crtc->setNext(m_primaryBuffer);
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
return true;
}
bool DrmPipeline::checkTestBuffer()
{
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
if (!pending.crtc || (m_primaryBuffer && m_primaryBuffer->size() == sourceSize())) {
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
return true;
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
auto backend = gpu()->eglBackend();
platforms/drm: simplify DrmPipeline::checkTestBuffer
2021-09-16 11:17:42 +00:00
QSharedPointer<DrmBuffer> buffer;
platforms/drm: re-use buffers for testing b38bb416 introduced flicker when restarting compositing because the DrmGpu::findWorkingCombination method usually creates new buffers for the commit, without rendering into them. Instead of that, re-use existing buffers where possible
2021-09-17 09:01:18 +00:00
// try to re-use buffers if possible.
const auto &checkBuffer = [this, backend, &buffer](const QSharedPointer<DrmBuffer> &buf){
platforms/drm: fix buffer re-using We don't always have explicit modifiers when we're using AMS CCBUG: 442677
2021-09-20 12:27:05 +00:00
const auto &mods = supportedModifiers(buf->format());
drm: Do not call the egl backend pointer when it's null It can be null, that's why we are also checking it down in the same function.
2021-10-20 01:33:01 +00:00
if (backend && buf->format() == backend->drmFormat()
platforms/drm: fix buffer re-using We don't always have explicit modifiers when we're using AMS CCBUG: 442677
2021-09-20 12:27:05 +00:00
&& (mods.isEmpty() || mods.contains(buf->modifier()))
platforms/drm: re-use buffers for testing b38bb416 introduced flicker when restarting compositing because the DrmGpu::findWorkingCombination method usually creates new buffers for the commit, without rendering into them. Instead of that, re-use existing buffers where possible
2021-09-17 09:01:18 +00:00
&& buf->size() == sourceSize()) {
buffer = buf;
}
};
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
if (pending.crtc->primaryPlane() && pending.crtc->primaryPlane()->next()) {
checkBuffer(pending.crtc->primaryPlane()->next());
} else if (pending.crtc->primaryPlane() && pending.crtc->primaryPlane()->current()) {
checkBuffer(pending.crtc->primaryPlane()->current());
} else if (pending.crtc->next()) {
checkBuffer(pending.crtc->next());
} else if (pending.crtc->current()) {
checkBuffer(pending.crtc->current());
platforms/drm: re-use buffers for testing b38bb416 introduced flicker when restarting compositing because the DrmGpu::findWorkingCombination method usually creates new buffers for the commit, without rendering into them. Instead of that, re-use existing buffers where possible
2021-09-17 09:01:18 +00:00
}
// if we don't have a fitting buffer already, get or create one
if (buffer) {
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
#if HAVE_GBM
platforms/drm: re-use buffers for testing b38bb416 introduced flicker when restarting compositing because the DrmGpu::findWorkingCombination method usually creates new buffers for the commit, without rendering into them. Instead of that, re-use existing buffers where possible
2021-09-17 09:01:18 +00:00
} else if (backend && m_output) {
platforms/drm: simplify DrmPipeline::checkTestBuffer
2021-09-16 11:17:42 +00:00
buffer = backend->renderTestFrame(m_output);
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
} else if (backend && gpu()->gbmDevice()) {
gbm_bo *bo = gbm_bo_create(gpu()->gbmDevice(), sourceSize().width(), sourceSize().height(), GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING);
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
if (!bo) {
return false;
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
buffer = QSharedPointer<DrmGbmBuffer>::create(gpu(), bo, nullptr);
platforms/drm: re-use buffers for testing b38bb416 introduced flicker when restarting compositing because the DrmGpu::findWorkingCombination method usually creates new buffers for the commit, without rendering into them. Instead of that, re-use existing buffers where possible
2021-09-17 09:01:18 +00:00
#endif
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
} else {
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
buffer = QSharedPointer<DrmDumbBuffer>::create(gpu(), sourceSize());
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
if (buffer && buffer->bufferId()) {
m_oldTestBuffer = m_primaryBuffer;
m_primaryBuffer = buffer;
return true;
}
return false;
}
fix wrong cursor hotspot under Wayland on VMs
2021-08-02 09:03:07 +00:00
bool DrmPipeline::setCursor(const QSharedPointer<DrmDumbBuffer> &buffer, const QPoint &hotspot)
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
{
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
return pending.crtc->setLegacyCursor(buffer, hotspot);
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
bool DrmPipeline::moveCursor(QPoint pos)
{
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
return pending.crtc->moveLegacyCursor(pos);
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
void DrmPipeline::prepareModeset()
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
{
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
if (!pending.crtc) {
m_connector->setPending(DrmConnector::PropertyIndex::CrtcId, 0);
return;
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
auto mode = m_connector->modes()[pending.modeIndex];
m_connector->setPending(DrmConnector::PropertyIndex::CrtcId, activePending() ? pending.crtc->id() : 0);
if (const auto &prop = m_connector->getProp(DrmConnector::PropertyIndex::Broadcast_RGB)) {
prop->setEnum(pending.rgbRange);
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
pending.crtc->setPending(DrmCrtc::PropertyIndex::Active, activePending());
pending.crtc->setPendingBlob(DrmCrtc::PropertyIndex::ModeId, activePending() ? &mode.mode : nullptr, sizeof(drmModeModeInfo));
pending.crtc->primaryPlane()->setPending(DrmPlane::PropertyIndex::CrtcId, activePending() ? pending.crtc->id() : 0);
pending.crtc->primaryPlane()->setTransformation(DrmPlane::Transformation::Rotate0);
pending.crtc->primaryPlane()->set(QPoint(0, 0), sourceSize(), QPoint(0, 0), mode.size);
m_formats = pending.crtc->primaryPlane()->formats();
}
void DrmPipeline::applyPendingChanges()
{
if (!pending.crtc) {
pending.active = false;
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
m_next = pending;
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
bool DrmPipeline::applyPendingChangesLegacy()
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
{
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
if (!pending.active && pending.crtc) {
drmModeSetCursor(gpu()->fd(), pending.crtc->id(), 0, 0, 0);
}
if (pending.active) {
Q_ASSERT(pending.crtc);
if (auto vrr = pending.crtc->getProp(DrmCrtc::PropertyIndex::VrrEnabled); !vrr->setPropertyLegacy(pending.syncMode == RenderLoopPrivate::SyncMode::Adaptive)) {
qCWarning(KWIN_DRM) << "Setting vrr failed!" << strerror(errno);
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
return false;
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
if (const auto &rgbRange = m_connector->getProp(DrmConnector::PropertyIndex::Broadcast_RGB)) {
rgbRange->setEnumLegacy(pending.rgbRange);
}
if (needsModeset() &&!legacyModeset()) {
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
return false;
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
m_connector->getProp(DrmConnector::PropertyIndex::Dpms)->setCurrent(DRM_MODE_DPMS_ON);
if (pending.gamma && drmModeCrtcSetGamma(gpu()->fd(), pending.crtc->id(), pending.gamma->size,
const_cast<uint16_t*>(pending.gamma->lut.red()),
const_cast<uint16_t*>(pending.gamma->lut.blue()),
const_cast<uint16_t*>(pending.gamma->lut.green())) != 0) {
qCWarning(KWIN_DRM) << "Setting gamma failed!" << strerror(errno);
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
return false;
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
pending.crtc->setLegacyCursor();
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
if (!m_connector->getProp(DrmConnector::PropertyIndex::Dpms)->setPropertyLegacy(pending.active ? DRM_MODE_DPMS_ON : DRM_MODE_DPMS_OFF)) {
qCWarning(KWIN_DRM) << "Setting legacy dpms failed!" << strerror(errno);
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
return false;
}
return true;
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
bool DrmPipeline::legacyModeset()
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
{
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
auto mode = m_connector->modes()[pending.modeIndex];
uint32_t connId = m_connector->id();
if (!checkTestBuffer() || drmModeSetCrtc(gpu()->fd(), pending.crtc->id(), m_primaryBuffer->bufferId(), 0, 0, &connId, 1, &mode.mode) != 0) {
qCWarning(KWIN_DRM) << "Modeset failed!" << strerror(errno);
pending = m_next;
m_primaryBuffer = m_oldTestBuffer;
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
return false;
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
m_oldTestBuffer = nullptr;
// make sure the buffer gets kept alive, or the modeset gets reverted by the kernel
if (pending.crtc->current()) {
pending.crtc->setNext(m_primaryBuffer);
platforms/drm: support Broadcast_RGB setting This allows the user to switch between full and limited rgb. BUG: 375666 BUG: 353689
2021-08-31 14:59:06 +00:00
} else {
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
pending.crtc->setCurrent(m_primaryBuffer);
platforms/drm: support Broadcast_RGB setting This allows the user to switch between full and limited rgb. BUG: 375666 BUG: 353689
2021-08-31 14:59:06 +00:00
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
return true;
platforms/drm: support Broadcast_RGB setting This allows the user to switch between full and limited rgb. BUG: 375666 BUG: 353689
2021-08-31 14:59:06 +00:00
}
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
QSize DrmPipeline::sourceSize() const
{
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
auto mode = m_connector->modes()[pending.modeIndex];
if (pending.transformation & (DrmPlane::Transformation::Rotate90 | DrmPlane::Transformation::Rotate270)) {
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
return mode.size.transposed();
}
return mode.size;
}
bool DrmPipeline::isCursorVisible() const
{
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
return pending.crtc && pending.crtc->isCursorVisible(QRect(QPoint(0, 0), m_connector->currentMode().size));
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
QPoint DrmPipeline::cursorPos() const
{
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
return pending.crtc->cursorPos();
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
DrmConnector *DrmPipeline::connector() const
{
return m_connector;
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
DrmGpu *DrmPipeline::gpu() const
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
{
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
return m_connector->gpu();
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
void DrmPipeline::pageFlipped(std::chrono::nanoseconds timestamp)
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
{
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
m_current.crtc->flipBuffer();
if (m_current.crtc->primaryPlane()) {
m_current.crtc->primaryPlane()->flipBuffer();
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
m_pageflipPending = false;
if (m_output) {
m_output->pageFlipped(timestamp);
}
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
platforms/drm: rename user data in DrmPipeline to output
2021-08-07 22:03:09 +00:00
void DrmPipeline::setOutput(DrmOutput *output)
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
{
platforms/drm: rename user data in DrmPipeline to output
2021-08-07 22:03:09 +00:00
m_output = output;
}
DrmOutput *DrmPipeline::output() const
{
return m_output;
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
platforms/drm: update properties on VT switch and failing commits
2021-06-03 13:50:37 +00:00
void DrmPipeline::updateProperties()
{
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
m_connector->updateProperties();
if (pending.crtc) {
pending.crtc->updateProperties();
if (pending.crtc->primaryPlane()) {
pending.crtc->primaryPlane()->updateProperties();
}
platforms/drm: update properties on VT switch and failing commits
2021-06-03 13:50:37 +00:00
}
platforms/drm: optimize cursor setting
2021-06-07 09:28:17 +00:00
// with legacy we don't know what happened to the cursor after VT switch
// so make sure it gets set again
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
pending.crtc->setLegacyCursor();
platforms/drm: update properties on VT switch and failing commits
2021-06-03 13:50:37 +00:00
}
platforms/drm: explicit modifiers IN_FORMATS contains information about which buffer formats can be scanned out with a given drm plane. Using these plane-specific format+modifier combinations as well as explicit modifiers in general can yield bandwidth and performance improvements, especially in multi-gpu systems.
2021-07-31 13:32:50 +00:00
bool DrmPipeline::isFormatSupported(uint32_t drmFormat) const
{
platforms/drm: simplify format stuff a bit
2021-09-16 10:48:38 +00:00
return m_formats.contains(drmFormat);
platforms/drm: explicit modifiers IN_FORMATS contains information about which buffer formats can be scanned out with a given drm plane. Using these plane-specific format+modifier combinations as well as explicit modifiers in general can yield bandwidth and performance improvements, especially in multi-gpu systems.
2021-07-31 13:32:50 +00:00
}
QVector<uint64_t> DrmPipeline::supportedModifiers(uint32_t drmFormat) const
{
platforms/drm: simplify format stuff a bit
2021-09-16 10:48:38 +00:00
return m_formats[drmFormat];
platforms/drm: explicit modifiers IN_FORMATS contains information about which buffer formats can be scanned out with a given drm plane. Using these plane-specific format+modifier combinations as well as explicit modifiers in general can yield bandwidth and performance improvements, especially in multi-gpu systems.
2021-07-31 13:32:50 +00:00
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
bool DrmPipeline::needsModeset() const
{
return pending.crtc != m_current.crtc
|| pending.active != m_current.active
|| pending.modeIndex != m_current.modeIndex
|| pending.rgbRange != m_current.rgbRange
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
|| pending.transformation != m_current.transformation
|| m_modesetPresentPending;
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
}
bool DrmPipeline::activePending() const
{
return pending.crtc && pending.active;
}
void DrmPipeline::revertPendingChanges()
{
pending = m_next;
}
platforms/drm: delay presentation for modesets Currently KWin is combining modesets with presentation, which causes problems when multiple monitors are used and crtcs need to be switched around, because taking away a CRTC from another output causes the driver to disable the other output. In order to avoid such problems, delay presentation until all pipelines are ready to present and then do a modeset with a single atomic commit. To process the resulting page flip events properly this commit also ports KWin to page_flip_handler2 and changes how the pageFlipped and notifyFrameFailed signals are processed.
2021-10-08 08:52:01 +00:00
bool DrmPipeline::pageflipPending() const
{
return m_pageflipPending;
}
bool DrmPipeline::modesetPresentPending() const
{
return m_modesetPresentPending;
}
DrmCrtc *DrmPipeline::currentCrtc() const
{
return m_current.crtc;
}
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
DrmGammaRamp::DrmGammaRamp(DrmGpu *gpu, const GammaRamp &lut)
: lut(lut)
, size(lut.size())
{
if (gpu->atomicModeSetting()) {
atomicLut = new drm_color_lut[size];
for (uint32_t i = 0; i < size; i++) {
atomicLut[i].red = lut.red()[i];
atomicLut[i].green = lut.green()[i];
atomicLut[i].blue = lut.blue()[i];
}
}
}
DrmGammaRamp::~DrmGammaRamp()
{
delete[] atomicLut;
}
platforms/drm: improve logging a bit Only print the flags once for all pipelines and include changed unused objects as well.
2021-10-20 08:43:35 +00:00
void DrmPipeline::printFlags(uint32_t flags)
{
if (flags == 0) {
qCWarning(KWIN_DRM) << "Flags: none";
} else {
qCWarning(KWIN_DRM) << "Flags:";
if (flags & DRM_MODE_PAGE_FLIP_EVENT) {
qCWarning(KWIN_DRM) << "\t DRM_MODE_PAGE_FLIP_EVENT";
}
if (flags & DRM_MODE_ATOMIC_ALLOW_MODESET) {
qCWarning(KWIN_DRM) << "\t DRM_MODE_ATOMIC_ALLOW_MODESET";
}
if (flags & DRM_MODE_PAGE_FLIP_ASYNC) {
qCWarning(KWIN_DRM) << "\t DRM_MODE_PAGE_FLIP_ASYNC";
}
}
}
void DrmPipeline::printProps(DrmObject *object, PrintMode mode)
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
{
auto list = object->properties();
platforms/drm: improve logging a bit Only print the flags once for all pipelines and include changed unused objects as well.
2021-10-20 08:43:35 +00:00
bool any = mode == PrintMode::All || std::any_of(list.constBegin(), list.constEnd(), [](const auto &prop){
return prop && !prop->isImmutable() && prop->needsCommit();
});
if (!any) {
return;
}
qCWarning(KWIN_DRM) << object->typeName() << object->id();
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
for (const auto &prop : list) {
if (prop) {
platforms/drm: make SRC properties readable They're 16.16 fixed point. Should make debugging easier
2021-09-16 10:37:44 +00:00
uint64_t current = prop->name().startsWith("SRC_") ? prop->current() >> 16 : prop->current();
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
if (prop->isImmutable() || !prop->needsCommit()) {
platforms/drm: improve logging a bit Only print the flags once for all pipelines and include changed unused objects as well.
2021-10-20 08:43:35 +00:00
if (mode == PrintMode::All) {
qCWarning(KWIN_DRM).nospace() << "\t" << prop->name() << ": " << current;
}
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
} else {
platforms/drm: make SRC properties readable They're 16.16 fixed point. Should make debugging easier
2021-09-16 10:37:44 +00:00
uint64_t pending = prop->name().startsWith("SRC_") ? prop->pending() >> 16 : prop->pending();
qCWarning(KWIN_DRM).nospace() << "\t" << prop->name() << ": " << current << "->" << pending;
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
}
}
}
void DrmPipeline::printDebugInfo() const
{
qCWarning(KWIN_DRM) << "Drm objects:";
platforms/drm: improve logging a bit Only print the flags once for all pipelines and include changed unused objects as well.
2021-10-20 08:43:35 +00:00
printProps(m_connector, PrintMode::All);
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
if (pending.crtc) {
platforms/drm: improve logging a bit Only print the flags once for all pipelines and include changed unused objects as well.
2021-10-20 08:43:35 +00:00
printProps(pending.crtc, PrintMode::All);
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
if (pending.crtc->primaryPlane()) {
platforms/drm: improve logging a bit Only print the flags once for all pipelines and include changed unused objects as well.
2021-10-20 08:43:35 +00:00
printProps(pending.crtc->primaryPlane(), PrintMode::All);
platforms/drm: more dynamic crtc assignment Hardware constraints limit the number of crtcs and which connector + crtc combinations can work together. The current code is searching for working combinations when a hotplug happens but that's not enough, it also needs to happen when the user enables or disables outputs and when modesets are done, and the configuration change needs to be applied with a single atomic commit. This commit removes the hard dependency of DrmPipeline on crtcs by moving the pending state of outputs from the drm objects to DrmPipeline itself, which ensures that it's independent from the set of drm objects currently used. It also changes requests from KScreen to be applied truly atomically.
2021-09-28 08:29:56 +00:00
}
platforms/drm: Introduce DrmPipeline DrmPipeline is now what contains all the thing related to drm calls, instead of DrmOutput. This allows for some more flexibility and tidies the code up a bit. Additionally instead of rolling back changes if presentation fails, changes are directly tested with atomic test only commits.
2021-05-25 22:05:17 +00:00
}
}
}
Reference in a new issue Copy permalink