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

636 lines
20 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"
#include "egl_gbm_backend.h"
#include "drm_buffer_gbm.h"
backends/drm,wayland: require gbm The ifdefs for have_gbm obfuscate the code unnecessarily - the drm backend is not a great experience with qpainter, so in practice noone should ship it without gbm anyways.
2021-11-10 11:41:57 +00:00
#include <gbm.h>
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)
{
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);
backends/drm: Mark frame failed if presenting null buffer If eglSwapBuffers() fails, there won't be a buffer and so we need to mark the frame as failed. Otherwise, the screen can be frozen. eglSwapBuffers() can fail if some effect calls makeOpenGLContext() between RenderBackend::beginFrame() and RenderBackend::endFrame(), which is the case with the zoom effect. It can set wrong draw surface in ZoomEffect::recreateTexture() BUG: 445412
2021-11-29 10:48:32 +00:00
Q_ASSERT(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
m_primaryBuffer = buffer;
backends/drm,wayland: require gbm The ifdefs for have_gbm obfuscate the code unnecessarily - the drm backend is not a great experience with qpainter, so in practice noone should ship it without gbm anyways.
2021-11-10 11:41:57 +00:00
auto buf = dynamic_cast<DrmGbmBuffer*>(buffer.data());
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
// with direct scanout disallow modesets, calling presentFailed() and logging warnings
backends/drm,wayland: require gbm The ifdefs for have_gbm obfuscate the code unnecessarily - the drm backend is not a great experience with qpainter, so in practice noone should ship it without gbm anyways.
2021-11-10 11:41:57 +00:00
bool directScanout = buf && buf->clientBuffer();
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 (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
backends/drm: inline DrmPipeline::updateProperties It's only used in one place
2021-11-22 10:33:26 +00:00
m_connector->updateProperties();
if (pending.crtc) {
pending.crtc->updateProperties();
if (pending.crtc->primaryPlane()) {
pending.crtc->primaryPlane()->updateProperties();
}
backends/drm: port cursors to atomic The cursor being set out-of-band with atomic commits creates problems because it can create false positive for atomic tests, if the cursor state gets changed in between an atomic test and its matching commit. This commit also ports the cursor to a swapchain instead of only one image. This is not strictly required but may prevent artifacts and will be needed for future optimisations.
2021-12-02 16:51:08 +00:00
if (pending.crtc->cursorPlane()) {
pending.crtc->cursorPlane()->updateProperties();
}
backends/drm: inline DrmPipeline::updateProperties It's only used in one place
2021-11-22 10:33:26 +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 (!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()) {
backends/drm: refactor DrmPipeline Split out more things from commitPipelines, and split out the legacy stuff into a separate file
2021-12-07 11:16:53 +00:00
return commitPipelinesAtomic(pipelines, mode, unusedObjects);
} else {
return commitPipelinesLegacy(pipelines, mode);
}
}
bool DrmPipeline::commitPipelinesAtomic(const QVector<DrmPipeline*> &pipelines, CommitMode mode, const QVector<DrmObject*> &unusedObjects)
{
drmModeAtomicReq *req = drmModeAtomicAlloc();
if (!req) {
backends/drm: adjust logging verbosity
2021-11-18 11:20:58 +00:00
qCCritical(KWIN_DRM) << "Failed to allocate drmModeAtomicReq!" << strerror(errno);
backends/drm: refactor DrmPipeline Split out more things from commitPipelines, and split out the legacy stuff into a separate file
2021-12-07 11:16:53 +00:00
return false;
}
uint32_t flags = 0;
const auto &failed = [pipelines, req, &flags, unusedObjects](){
drmModeAtomicFree(req);
printFlags(flags);
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) {
backends/drm: refactor DrmPipeline Split out more things from commitPipelines, and split out the legacy stuff into a separate file
2021-12-07 11:16:53 +00:00
pipeline->printDebugInfo();
pipeline->atomicCommitFailed();
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
}
backends/drm: refactor DrmPipeline Split out more things from commitPipelines, and split out the legacy stuff into a separate file
2021-12-07 11:16:53 +00:00
for (const auto &obj : unusedObjects) {
printProps(obj, PrintMode::OnlyChanged);
obj->rollbackPending();
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
}
backends/drm: refactor DrmPipeline Split out more things from commitPipelines, and split out the legacy stuff into a separate file
2021-12-07 11:16:53 +00:00
return false;
};
for (const auto &pipeline : pipelines) {
if (!pipeline->checkTestBuffer()) {
qCWarning(KWIN_DRM) << "Checking test buffer failed for" << mode;
platforms/drm: improve warning messages in DrmPipeline
2021-09-09 10:52:04 +00:00
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
}
backends/drm: refactor DrmPipeline Split out more things from commitPipelines, and split out the legacy stuff into a separate file
2021-12-07 11:16:53 +00:00
if (!pipeline->populateAtomicValues(req, flags)) {
qCWarning(KWIN_DRM) << "Populating atomic values failed for" << mode;
platforms/drm: improve warning messages in DrmPipeline
2021-09-09 10:52:04 +00:00
return failed();
}
backends/drm: refactor DrmPipeline Split out more things from commitPipelines, and split out the legacy stuff into a separate file
2021-12-07 11:16:53 +00:00
}
for (const auto &unused : unusedObjects) {
unused->disable();
if (unused->needsModeset()) {
flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
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
}
backends/drm: refactor DrmPipeline Split out more things from commitPipelines, and split out the legacy stuff into a separate file
2021-12-07 11:16:53 +00:00
if (!unused->atomicPopulate(req)) {
qCWarning(KWIN_DRM) << "Populating atomic values failed for unused resource" << unused;
return failed();
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
}
backends/drm: refactor DrmPipeline Split out more things from commitPipelines, and split out the legacy stuff into a separate file
2021-12-07 11:16:53 +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);
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 {
backends/drm: refactor DrmPipeline Split out more things from commitPipelines, and split out the legacy stuff into a separate file
2021-12-07 11:16:53 +00:00
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) {
backends/drm: adjust logging verbosity
2021-11-18 11:20:58 +00:00
qCDebug(KWIN_DRM) << "Atomic test for" << mode << "failed!" << strerror(errno);
backends/drm: refactor DrmPipeline Split out more things from commitPipelines, and split out the legacy stuff into a separate file
2021-12-07 11:16:53 +00:00
return failed();
}
if (mode != CommitMode::Test && drmModeAtomicCommit(pipelines[0]->gpu()->fd(), req, flags, nullptr) != 0) {
backends/drm: adjust logging verbosity
2021-11-18 11:20:58 +00:00
qCCritical(KWIN_DRM) << "Atomic commit failed! This should never happen!" << strerror(errno);
backends/drm: refactor DrmPipeline Split out more things from commitPipelines, and split out the legacy stuff into a separate file
2021-12-07 11:16:53 +00:00
return failed();
}
for (const auto &pipeline : pipelines) {
backends/drm: refactor legacy cursor This commit does away with the special handling of the legacy cursor and makes it be applied directly in DrmPipeline, using the same state as the atomic cursor and without dirty flags.
2021-12-07 11:34:47 +00:00
pipeline->atomicCommitSuccessful(mode);
backends/drm: refactor DrmPipeline Split out more things from commitPipelines, and split out the legacy stuff into a separate file
2021-12-07 11:16:53 +00:00
}
for (const auto &obj : unusedObjects) {
obj->commitPending();
if (mode != CommitMode::Test) {
obj->commit();
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
}
backends/drm: refactor DrmPipeline Split out more things from commitPipelines, and split out the legacy stuff into a separate file
2021-12-07 11:16:53 +00:00
drmModeAtomicFree(req);
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()) {
backends/drm: minor refactor of DrmPipeline
2021-12-14 14:37:23 +00:00
prepareAtomicModeset();
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
}
platforms/drm: kill the EglStreams backend The proprietary NVidia driver now supports gbm, which vastly improves the user experience. For older devices that will not get gbm support dropping EglStreams will likely not have a big impact as it has several session breaking issues anyways. By removing the backend a lot of logic can be simplified, most notably multi-gpu.
2021-11-10 11:17:40 +00:00
if (activePending()) {
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
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) {
backends/drm: port cursors to atomic The cursor being set out-of-band with atomic commits creates problems because it can create false positive for atomic tests, if the cursor state gets changed in between an atomic test and its matching commit. This commit also ports the cursor to a swapchain instead of only one image. This is not strictly required but may prevent artifacts and will be needed for future optimisations.
2021-12-02 16:51:08 +00:00
pending.crtc->setPending(DrmCrtc::PropertyIndex::VrrEnabled, pending.syncMode == RenderLoopPrivate::SyncMode::Adaptive);
pending.crtc->setPending(DrmCrtc::PropertyIndex::Gamma_LUT, pending.gamma ? pending.gamma->blobId() : 0);
platforms/drm: Move ownership of mode blob to connector mode The main motivation behind this change is to move management of drm blobs out of property wrappers in specialized wrappers to simplify state management with blobs. Connector mode blobs are created on demand.
2021-09-28 08:30:57 +00:00
auto modeSize = m_connector->modes()[pending.modeIndex]->size();
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->primaryPlane()->set(QPoint(0, 0), m_primaryBuffer ? m_primaryBuffer->size() : modeSize, QPoint(0, 0), modeSize);
pending.crtc->primaryPlane()->setBuffer(activePending() ? m_primaryBuffer.get() : nullptr);
backends/drm: port cursors to atomic The cursor being set out-of-band with atomic commits creates problems because it can create false positive for atomic tests, if the cursor state gets changed in between an atomic test and its matching commit. This commit also ports the cursor to a swapchain instead of only one image. This is not strictly required but may prevent artifacts and will be needed for future optimisations.
2021-12-02 16:51:08 +00:00
if (pending.crtc->cursorPlane()) {
pending.crtc->cursorPlane()->set(QPoint(0, 0), gpu()->cursorSize(), pending.cursorPos, gpu()->cursorSize());
pending.crtc->cursorPlane()->setBuffer(activePending() ? pending.cursorBo.get() : nullptr);
pending.crtc->cursorPlane()->setPending(DrmPlane::PropertyIndex::CrtcId, (activePending() && pending.cursorBo) ? pending.crtc->id() : 0);
}
}
if (!m_connector->atomicPopulate(req)) {
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
}
backends/drm: port cursors to atomic The cursor being set out-of-band with atomic commits creates problems because it can create false positive for atomic tests, if the cursor state gets changed in between an atomic test and its matching commit. This commit also ports the cursor to a swapchain instead of only one image. This is not strictly required but may prevent artifacts and will be needed for future optimisations.
2021-12-02 16:51:08 +00:00
if (pending.crtc) {
if (!pending.crtc->atomicPopulate(req)) {
return false;
}
if (!pending.crtc->primaryPlane()->atomicPopulate(req)) {
return false;
}
if (pending.crtc->cursorPlane() && !pending.crtc->cursorPlane()->atomicPopulate(req)) {
return false;
}
}
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
}
backends/drm: minor refactor of DrmPipeline
2021-12-14 14:37:23 +00:00
void DrmPipeline::prepareAtomicModeset()
{
if (!pending.crtc) {
m_connector->setPending(DrmConnector::PropertyIndex::CrtcId, 0);
return;
}
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);
}
pending.crtc->setPending(DrmCrtc::PropertyIndex::Active, activePending());
pending.crtc->setPending(DrmCrtc::PropertyIndex::ModeId, activePending() ? mode->blobId() : 0);
pending.crtc->primaryPlane()->setPending(DrmPlane::PropertyIndex::CrtcId, activePending() ? pending.crtc->id() : 0);
pending.crtc->primaryPlane()->setTransformation(DrmPlane::Transformation::Rotate0);
if (pending.crtc->cursorPlane()) {
pending.crtc->cursorPlane()->setTransformation(DrmPlane::Transformation::Rotate0);
}
}
backends/drm: refactor DrmPipeline Split out more things from commitPipelines, and split out the legacy stuff into a separate file
2021-12-07 11:16:53 +00:00
void DrmPipeline::atomicCommitFailed()
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
{
backends/drm: refactor DrmPipeline Split out more things from commitPipelines, and split out the legacy stuff into a separate file
2021-12-07 11:16:53 +00:00
if (m_oldTestBuffer) {
m_primaryBuffer = m_oldTestBuffer;
m_oldTestBuffer = 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
}
backends/drm: refactor DrmPipeline Split out more things from commitPipelines, and split out the legacy stuff into a separate file
2021-12-07 11:16:53 +00:00
m_connector->rollbackPending();
if (pending.crtc) {
pending.crtc->rollbackPending();
pending.crtc->primaryPlane()->rollbackPending();
if (pending.crtc->cursorPlane()) {
pending.crtc->cursorPlane()->rollbackPending();
}
}
}
backends/drm: refactor legacy cursor This commit does away with the special handling of the legacy cursor and makes it be applied directly in DrmPipeline, using the same state as the atomic cursor and without dirty flags.
2021-12-07 11:34:47 +00:00
void DrmPipeline::atomicCommitSuccessful(CommitMode mode)
backends/drm: refactor DrmPipeline Split out more things from commitPipelines, and split out the legacy stuff into a separate file
2021-12-07 11:16:53 +00:00
{
m_oldTestBuffer = nullptr;
m_connector->commitPending();
if (pending.crtc) {
pending.crtc->commitPending();
pending.crtc->primaryPlane()->commitPending();
if (pending.crtc->cursorPlane()) {
pending.crtc->cursorPlane()->commitPending();
}
}
if (mode != CommitMode::Test) {
if (activePending()) {
m_pageflipPending = true;
}
m_connector->commit();
if (pending.crtc) {
pending.crtc->commit();
pending.crtc->primaryPlane()->setNext(m_primaryBuffer);
pending.crtc->primaryPlane()->commit();
if (pending.crtc->cursorPlane()) {
pending.crtc->cursorPlane()->setNext(pending.cursorBo);
pending.crtc->cursorPlane()->commit();
}
}
m_current = pending;
if (mode == CommitMode::CommitModeset && activePending()) {
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
}
}
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());
backends/drm: deep color support This commit makes 10 bits per color channel the default color depth, which should reduce banding on outputs that support color formats with more than 8 bits per color channel. In order to support this the commit also removes the dependency of the EglGbmBackend on a specific format and EglConfig and instead makes those per-Output properties.
2021-11-10 13:47:13 +00:00
if (backend && buf->format() == backend->drmFormat(m_output)
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
backends/drm,wayland: require gbm The ifdefs for have_gbm obfuscate the code unnecessarily - the drm backend is not a great experience with qpainter, so in practice noone should ship it without gbm anyways.
2021-11-10 11:41:57 +00:00
if (!buffer) {
if (backend && m_output) {
buffer = backend->renderTestFrame(m_output);
} else if (backend && gpu()->gbmDevice()) {
backends/drm: port cursors to atomic The cursor being set out-of-band with atomic commits creates problems because it can create false positive for atomic tests, if the cursor state gets changed in between an atomic test and its matching commit. This commit also ports the cursor to a swapchain instead of only one image. This is not strictly required but may prevent artifacts and will be needed for future optimisations.
2021-12-02 16:51:08 +00:00
gbm_bo *bo = gbm_bo_create(gpu()->gbmDevice(), sourceSize().width(), sourceSize().height(), DRM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING);
backends/drm,wayland: require gbm The ifdefs for have_gbm obfuscate the code unnecessarily - the drm backend is not a great experience with qpainter, so in practice noone should ship it without gbm anyways.
2021-11-10 11:41:57 +00:00
if (!bo) {
return false;
}
buffer = QSharedPointer<DrmGbmBuffer>::create(gpu(), bo, nullptr);
} else {
backends/drm: port cursors to atomic The cursor being set out-of-band with atomic commits creates problems because it can create false positive for atomic tests, if the cursor state gets changed in between an atomic test and its matching commit. This commit also ports the cursor to a swapchain instead of only one image. This is not strictly required but may prevent artifacts and will be needed for future optimisations.
2021-12-02 16:51:08 +00:00
buffer = QSharedPointer<DrmDumbBuffer>::create(gpu(), sourceSize(), DRM_FORMAT_XRGB8888);
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
{
backends/drm: refactor legacy cursor This commit does away with the special handling of the legacy cursor and makes it be applied directly in DrmPipeline, using the same state as the atomic cursor and without dirty flags.
2021-12-07 11:34:47 +00:00
if (pending.cursorBo == buffer && pending.cursorHotspot == hotspot) {
return true;
}
backends/drm: port cursors to atomic The cursor being set out-of-band with atomic commits creates problems because it can create false positive for atomic tests, if the cursor state gets changed in between an atomic test and its matching commit. This commit also ports the cursor to a swapchain instead of only one image. This is not strictly required but may prevent artifacts and will be needed for future optimisations.
2021-12-02 16:51:08 +00:00
bool result;
const bool visibleBefore = isCursorVisible();
backends/drm: refactor legacy cursor This commit does away with the special handling of the legacy cursor and makes it be applied directly in DrmPipeline, using the same state as the atomic cursor and without dirty flags.
2021-12-07 11:34:47 +00:00
pending.cursorBo = buffer;
pending.cursorHotspot = hotspot;
backends/drm: port cursors to atomic The cursor being set out-of-band with atomic commits creates problems because it can create false positive for atomic tests, if the cursor state gets changed in between an atomic test and its matching commit. This commit also ports the cursor to a swapchain instead of only one image. This is not strictly required but may prevent artifacts and will be needed for future optimisations.
2021-12-02 16:51:08 +00:00
// explicitly check for the cursor plane and not for AMS, as we might not always have one
if (pending.crtc->cursorPlane()) {
result = commitPipelines({this}, CommitMode::Test);
} else {
backends/drm: refactor legacy cursor This commit does away with the special handling of the legacy cursor and makes it be applied directly in DrmPipeline, using the same state as the atomic cursor and without dirty flags.
2021-12-07 11:34:47 +00:00
result = setCursorLegacy();
backends/drm: port cursors to atomic The cursor being set out-of-band with atomic commits creates problems because it can create false positive for atomic tests, if the cursor state gets changed in between an atomic test and its matching commit. This commit also ports the cursor to a swapchain instead of only one image. This is not strictly required but may prevent artifacts and will be needed for future optimisations.
2021-12-02 16:51:08 +00:00
}
backends/drm: refactor legacy cursor This commit does away with the special handling of the legacy cursor and makes it be applied directly in DrmPipeline, using the same state as the atomic cursor and without dirty flags.
2021-12-07 11:34:47 +00:00
if (result) {
m_next = pending;
if (m_output && (visibleBefore || isCursorVisible())) {
m_output->renderLoop()->scheduleRepaint();
}
} else {
pending = m_next;
backends/drm: port cursors to atomic The cursor being set out-of-band with atomic commits creates problems because it can create false positive for atomic tests, if the cursor state gets changed in between an atomic test and its matching commit. This commit also ports the cursor to a swapchain instead of only one image. This is not strictly required but may prevent artifacts and will be needed for future optimisations.
2021-12-02 16:51:08 +00:00
}
return result;
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)
{
backends/drm: refactor legacy cursor This commit does away with the special handling of the legacy cursor and makes it be applied directly in DrmPipeline, using the same state as the atomic cursor and without dirty flags.
2021-12-07 11:34:47 +00:00
if (pending.cursorPos == pos) {
return true;
}
backends/drm: port cursors to atomic The cursor being set out-of-band with atomic commits creates problems because it can create false positive for atomic tests, if the cursor state gets changed in between an atomic test and its matching commit. This commit also ports the cursor to a swapchain instead of only one image. This is not strictly required but may prevent artifacts and will be needed for future optimisations.
2021-12-02 16:51:08 +00:00
const bool visibleBefore = isCursorVisible();
backends/drm: Fix stuck cursors Currently, if you move the cursor really fast between two outputs, there may be stuck cursor on the previous output. We need to query the old cursor visibility status before updating the cursor position, otherwise the drm backend may not schedule an update to move the cursor offscreen.
2021-12-09 19:28:00 +00:00
bool result;
pending.cursorPos = pos;
backends/drm: port cursors to atomic The cursor being set out-of-band with atomic commits creates problems because it can create false positive for atomic tests, if the cursor state gets changed in between an atomic test and its matching commit. This commit also ports the cursor to a swapchain instead of only one image. This is not strictly required but may prevent artifacts and will be needed for future optimisations.
2021-12-02 16:51:08 +00:00
// explicitly check for the cursor plane and not for AMS, as we might not always have one
if (pending.crtc->cursorPlane()) {
result = commitPipelines({this}, CommitMode::Test);
} else {
backends/drm: refactor legacy cursor This commit does away with the special handling of the legacy cursor and makes it be applied directly in DrmPipeline, using the same state as the atomic cursor and without dirty flags.
2021-12-07 11:34:47 +00:00
result = moveCursorLegacy();
backends/drm: port cursors to atomic The cursor being set out-of-band with atomic commits creates problems because it can create false positive for atomic tests, if the cursor state gets changed in between an atomic test and its matching commit. This commit also ports the cursor to a swapchain instead of only one image. This is not strictly required but may prevent artifacts and will be needed for future optimisations.
2021-12-02 16:51:08 +00:00
}
backends/drm: refactor legacy cursor This commit does away with the special handling of the legacy cursor and makes it be applied directly in DrmPipeline, using the same state as the atomic cursor and without dirty flags.
2021-12-07 11:34:47 +00:00
if (result) {
m_next = pending;
if (m_output && (visibleBefore || isCursorVisible())) {
m_output->renderLoop()->scheduleRepaint();
}
} else {
pending = m_next;
backends/drm: port cursors to atomic The cursor being set out-of-band with atomic commits creates problems because it can create false positive for atomic tests, if the cursor state gets changed in between an atomic test and its matching commit. This commit also ports the cursor to a swapchain instead of only one image. This is not strictly required but may prevent artifacts and will be needed for future optimisations.
2021-12-02 16:51:08 +00:00
}
return result;
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::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
}
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: Move ownership of mode blob to connector mode The main motivation behind this change is to move management of drm blobs out of property wrappers in specialized wrappers to simplify state management with blobs. Connector mode blobs are created on demand.
2021-09-28 08:30:57 +00:00
return mode->size().transposed();
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: Move ownership of mode blob to connector mode The main motivation behind this change is to move management of drm blobs out of property wrappers in specialized wrappers to simplify state management with blobs. Connector mode blobs are created on demand.
2021-09-28 08:30:57 +00:00
return mode->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
}
bool DrmPipeline::isCursorVisible() const
{
backends/drm: port cursors to atomic The cursor being set out-of-band with atomic commits creates problems because it can create false positive for atomic tests, if the cursor state gets changed in between an atomic test and its matching commit. This commit also ports the cursor to a swapchain instead of only one image. This is not strictly required but may prevent artifacts and will be needed for future optimisations.
2021-12-02 16:51:08 +00:00
const QRect mode = QRect(QPoint(), m_connector->modes()[pending.modeIndex]->size());
backends/drm: refactor legacy cursor This commit does away with the special handling of the legacy cursor and makes it be applied directly in DrmPipeline, using the same state as the atomic cursor and without dirty flags.
2021-12-07 11:34:47 +00:00
return pending.cursorBo && QRect(pending.cursorPos, pending.cursorBo->size()).intersects(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
}
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
}
backends/drm: port cursors to atomic The cursor being set out-of-band with atomic commits creates problems because it can create false positive for atomic tests, if the cursor state gets changed in between an atomic test and its matching commit. This commit also ports the cursor to a swapchain instead of only one image. This is not strictly required but may prevent artifacts and will be needed for future optimisations.
2021-12-02 16:51:08 +00:00
if (m_current.crtc->cursorPlane()) {
m_current.crtc->cursorPlane()->flipBuffer();
}
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
}
backends/drm: improve dmabuf feedback Instead of only allowing the current format, send the default tranches modified to only contain formats and modifiers suitable for scanout. In order to not fail when we can't do direct scanout with a given format (because that may require a modeset, which we don't allow), keep a blacklist of attempted formats and modifiers for the current client.
2021-12-30 18:36:54 +00:00
static const QMap<uint32_t, QVector<uint64_t>> legacyFormats = {
{DRM_FORMAT_XRGB8888, {}},
{DRM_FORMAT_ARGB8888, {}}
};
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
{
backends/drm: don't cache formats While it could be useful with tiled displays, the isFormatSupported and supportedModifier functions can be called before prepareModeset, so where m_formats is still empty. Additionally they're neither in a hot path nor performance critical.
2021-11-10 15:18:53 +00:00
if (pending.crtc) {
if (pending.crtc->primaryPlane()) {
return pending.crtc->primaryPlane()->formats().contains(drmFormat);
} else {
backends/drm: improve dmabuf feedback Instead of only allowing the current format, send the default tranches modified to only contain formats and modifiers suitable for scanout. In order to not fail when we can't do direct scanout with a given format (because that may require a modeset, which we don't allow), keep a blacklist of attempted formats and modifiers for the current client.
2021-12-30 18:36:54 +00:00
return legacyFormats.keys().contains(drmFormat);
backends/drm: don't cache formats While it could be useful with tiled displays, the isFormatSupported and supportedModifier functions can be called before prepareModeset, so where m_formats is still empty. Additionally they're neither in a hot path nor performance critical.
2021-11-10 15:18:53 +00:00
}
} else {
return false;
}
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
{
backends/drm: don't cache formats While it could be useful with tiled displays, the isFormatSupported and supportedModifier functions can be called before prepareModeset, so where m_formats is still empty. Additionally they're neither in a hot path nor performance critical.
2021-11-10 15:18:53 +00:00
if (pending.crtc && pending.crtc->primaryPlane()) {
return pending.crtc->primaryPlane()->formats()[drmFormat];
} else {
return {};
}
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
}
backends/drm: improve dmabuf feedback Instead of only allowing the current format, send the default tranches modified to only contain formats and modifiers suitable for scanout. In order to not fail when we can't do direct scanout with a given format (because that may require a modeset, which we don't allow), keep a blacklist of attempted formats and modifiers for the current client.
2021-12-30 18:36:54 +00:00
QMap<uint32_t, QVector<uint64_t>> DrmPipeline::supportedFormats() const
{
if (pending.crtc) {
if (pending.crtc->primaryPlane()) {
return pending.crtc->primaryPlane()->formats();
} else {
return legacyFormats;
}
} else {
return {};
}
}
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;
}
backends/drm: Notify about failed frames if there are actually pending frames In case a modeset needs to be performed, the drm backend will test all pipelines to ensure that new mode won't cause any bandwidth issues on other outputs, etc. To do that, it may delay presenting frames. If the new configuration doesn't work, it needs to notify about failed frames. However, the relevant code that notifies the RenderLoop about failed atomic commits doesn't check if there's actually a pending modeset present. When switching between VTs, systemd can revoke master permissions from kwin. To make things even more trickier, kwin can try to present a frame in that short time span.
2021-11-25 09:15:50 +00:00
void DrmPipeline::resetModesetPresentPending()
{
m_modesetPresentPending = 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
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)
platforms/drm: move gamma blob ownership to DrmPipeline::Gamma
2021-10-22 10:17:59 +00:00
: m_gpu(gpu)
, m_lut(lut)
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: move gamma blob ownership to DrmPipeline::Gamma
2021-10-22 10:17:59 +00:00
QVector<drm_color_lut> atomicLut(lut.size());
for (uint32_t i = 0; i < lut.size(); i++) {
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
atomicLut[i].red = lut.red()[i];
atomicLut[i].green = lut.green()[i];
atomicLut[i].blue = lut.blue()[i];
}
platforms/drm: move gamma blob ownership to DrmPipeline::Gamma
2021-10-22 10:17:59 +00:00
if (drmModeCreatePropertyBlob(gpu->fd(), atomicLut.data(), sizeof(drm_color_lut) * lut.size(), &m_blobId) != 0) {
qCWarning(KWIN_DRM) << "Failed to create gamma blob!" << strerror(errno);
}
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()
{
platforms/drm: move gamma blob ownership to DrmPipeline::Gamma
2021-10-22 10:17:59 +00:00
if (m_blobId != 0) {
drmModeDestroyPropertyBlob(m_gpu->fd(), m_blobId);
}
}
uint32_t DrmGammaRamp::blobId() const
{
return m_blobId;
}
uint32_t DrmGammaRamp::size() const
{
return m_lut.size();
}
uint16_t *DrmGammaRamp::red() const
{
return const_cast<uint16_t*>(m_lut.red());
}
uint16_t *DrmGammaRamp::green() const
{
return const_cast<uint16_t*>(m_lut.green());
}
uint16_t *DrmGammaRamp::blue() const
{
return const_cast<uint16_t*>(m_lut.blue());
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: 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) {
backends/drm: adjust logging verbosity
2021-11-18 11:20:58 +00:00
qCDebug(KWIN_DRM) << "Flags: none";
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
} else {
backends/drm: adjust logging verbosity
2021-11-18 11:20:58 +00:00
qCDebug(KWIN_DRM) << "Flags:";
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 (flags & DRM_MODE_PAGE_FLIP_EVENT) {
backends/drm: adjust logging verbosity
2021-11-18 11:20:58 +00:00
qCDebug(KWIN_DRM) << "\t DRM_MODE_PAGE_FLIP_EVENT";
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 (flags & DRM_MODE_ATOMIC_ALLOW_MODESET) {
backends/drm: adjust logging verbosity
2021-11-18 11:20:58 +00:00
qCDebug(KWIN_DRM) << "\t DRM_MODE_ATOMIC_ALLOW_MODESET";
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 (flags & DRM_MODE_PAGE_FLIP_ASYNC) {
backends/drm: adjust logging verbosity
2021-11-18 11:20:58 +00:00
qCDebug(KWIN_DRM) << "\t DRM_MODE_PAGE_FLIP_ASYNC";
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::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;
}
backends/drm: adjust logging verbosity
2021-11-18 11:20:58 +00:00
qCDebug(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) {
backends/drm: adjust logging verbosity
2021-11-18 11:20:58 +00:00
qCDebug(KWIN_DRM).nospace() << "\t" << prop->name() << ": " << current;
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
}
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();
backends/drm: adjust logging verbosity
2021-11-18 11:20:58 +00:00
qCDebug(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
{
backends/drm: adjust logging verbosity
2021-11-18 11:20:58 +00:00
qCDebug(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
}
backends/drm: port cursors to atomic The cursor being set out-of-band with atomic commits creates problems because it can create false positive for atomic tests, if the cursor state gets changed in between an atomic test and its matching commit. This commit also ports the cursor to a swapchain instead of only one image. This is not strictly required but may prevent artifacts and will be needed for future optimisations.
2021-12-02 16:51:08 +00:00
if (pending.crtc->cursorPlane()) {
printProps(pending.crtc->cursorPlane(), PrintMode::All);
}
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