Differential D2370 Diff 5854 plugins/platforms/drm/drm_output.cpp

Changeset View

Standalone View

View Options

plugins/platforms/drm/drm_output.cpp

Context not available.
19*********************************************************************/ 19​*********************************************************************/
20#include "drm_output.h" 20​#include "drm_output.h"
21#include "drm_backend.h" 21​#include "drm_backend.h"
22​#include "drm_object_plane.h"
23​#include "drm_object_crtc.h"
24​#include "drm_object_connector.h"
25​
26​#include <errno.h>
22 27​
23#include "composite.h" 28​#include "composite.h"
24#include "logind.h" 29​#include "logind.h"
Context not available.
58{ 63​{
59 hideCursor(); 64​ hideCursor();
60 cleanupBlackBuffer(); 65​ cleanupBlackBuffer();
66​ delete m_crtc;
67​ delete m_conn;
61 delete m_waylandOutput.data(); 68​ delete m_waylandOutput.data();
62 delete m_waylandOutputDevice.data(); 69​ delete m_waylandOutputDevice.data();
63} 70​}
Context not available.
97 return QRect(m_globalPos, size()); 104​ return QRect(m_globalPos, size());
98} 105​}
99 106​
100bool DrmOutput::present(DrmBuffer *buffer) ​
101{ ​
102 if (!buffer || buffer->bufferId() == 0) { ​
103 return false; ​
104 } ​
105 if (!LogindIntegration::self()->isActiveSession()) { ​
106 m_currentBuffer = buffer; ​
107 return false; ​
108 } ​
109 if (m_dpmsMode != DpmsMode::On) { ​
110 return false; ​
111 } ​
112 if (m_currentBuffer) { ​
113 return false; ​
114 } ​
115 if (m_lastStride != buffer->stride() || m_lastGbm != buffer->isGbm()) { ​
116 // need to set a new mode first ​
117 if (!setMode(buffer)) { ​
118 return false; ​
119 } ​
120 } ​
121 const bool ok = drmModePageFlip(m_backend->fd(), m_crtcId, buffer->bufferId(), DRM_MODE_PAGE_FLIP_EVENT, this) == 0; ​
122 if (ok) { ​
123 m_currentBuffer = buffer; ​
124 } else { ​
125 qCWarning(KWIN_DRM) << "Page flip failed"; ​
126 buffer->releaseGbm(); ​
127 } ​
128 return ok; ​
129} ​
130 ​
131void DrmOutput::pageFlipped() ​
132{ ​
133 if (!m_currentBuffer) { ​
134 return; ​
135 } ​
136 m_currentBuffer->releaseGbm(); ​
137 m_currentBuffer = nullptr; ​
138 cleanupBlackBuffer(); ​
139} ​
140 ​
141void DrmOutput::cleanupBlackBuffer() ​
142{ ​
143 if (m_blackBuffer) { ​
144 delete m_blackBuffer; ​
145 m_blackBuffer = nullptr; ​
146 } ​
147} ​
148 ​
149static KWayland::Server::OutputInterface::DpmsMode toWaylandDpmsMode(DrmOutput::DpmsMode mode) 107​static KWayland::Server::OutputInterface::DpmsMode toWaylandDpmsMode(DrmOutput::DpmsMode mode)
150{ 108​{
151 using namespace KWayland::Server; 109​ using namespace KWayland::Server;
graesslinUnsubmitted
Done

I fear this could result in crashers of the QPainter compositor. It's using two buffers and if the old one gets deleted here it will try to use it again in the next frame, which will boom. No real idea how we can do that. The best idea I have right now is a flag: deleteAfterPageFlip in DrmBuffer.

graesslin: I fear this could result in crashers of the QPainter compositor. It's using two buffers and if…
romanggAuthorUnsubmitted
Done

This is definitely a grave issue, which I overlooked. Do you want to think a little bit longer about another solution or should we go with the flag? At the moment I also can't think of something better.

romangg: This is definitely a grave issue, which I overlooked. Do you want to think a little bit longer…
graesslinUnsubmitted
Done

If I find something better I will tell, otherwise flag it is.

graesslin: If I find something better I will tell, otherwise flag it is.
graesslinUnsubmitted
Done

nitpick: coding style

graesslin: nitpick: coding style
graesslinUnsubmitted
Done

nitpick: coding style

graesslin: nitpick: coding style
graesslinUnsubmitted
Done

nitpick: braces missing

graesslin: nitpick: braces missing
graesslinUnsubmitted
Done

nitpick: whitespaces

graesslin: nitpick: whitespaces
Context not available.
185 initEdid(connector); 143​ initEdid(connector);
186 initDpms(connector); 144​ initDpms(connector);
187 initUuid(); 145​ initUuid();
146​ if (m_backend->atomicModeSetting()) {
147​ if (!initPrimaryPlane()) {
148​ return false;
149​ }
150​ }
188 m_savedCrtc.reset(drmModeGetCrtc(m_backend->fd(), m_crtcId)); 151​ m_savedCrtc.reset(drmModeGetCrtc(m_backend->fd(), m_crtcId));
189 if (!blank()) { 152​ if (!blank()) {
190 return false; 153​ return false;
Context not available.
240 203​
241 // read in mode information 204​ // read in mode information
242 for (int i = 0; i < connector->count_modes; ++i) { 205​ for (int i = 0; i < connector->count_modes; ++i) {
206​
207​ // TODO: in AMS here we could read and store for later every mode's blob_id
208​ // would simplify isCurrentMode(..) and presentAtomically(..) in case of mode set
209​
243 auto *m = &connector->modes[i]; 210​ auto *m = &connector->modes[i];
244 KWayland::Server::OutputInterface::ModeFlags flags; 211​ KWayland::Server::OutputInterface::ModeFlags flags;
245 KWayland::Server::OutputDeviceInterface::ModeFlags deviceflags; 212​ KWayland::Server::OutputDeviceInterface::ModeFlags deviceflags;
Context not available.
321 && qstrcmp(mode->name, m_mode.name) == 0; 288​ && qstrcmp(mode->name, m_mode.name) == 0;
322} 289​}
323 290​
324bool DrmOutput::blank() ​
325{ ​
326 if (!m_blackBuffer) { ​
327 m_blackBuffer = m_backend->createBuffer(size()); ​
328 if (!m_blackBuffer->map()) { ​
329 cleanupBlackBuffer(); ​
330 return false; ​
331 } ​
332 m_blackBuffer->image()->fill(Qt::black); ​
333 } ​
334 return setMode(m_blackBuffer); ​
335} ​
336 ​
337bool DrmOutput::setMode(DrmBuffer *buffer) ​
338{ ​
339 if (drmModeSetCrtc(m_backend->fd(), m_crtcId, buffer->bufferId(), 0, 0, &m_connector, 1, &m_mode) == 0) { ​
340 m_lastStride = buffer->stride(); ​
341 m_lastGbm = buffer->isGbm(); ​
342 return true; ​
343 } else { ​
344 qCWarning(KWIN_DRM) << "Mode setting failed"; ​
345 return false; ​
346 } ​
347} ​
348 ​
349static bool verifyEdidHeader(drmModePropertyBlobPtr edid) 291​static bool verifyEdidHeader(drmModePropertyBlobPtr edid)
350{ 292​{
351 const uint8_t *data = reinterpret_cast<uint8_t*>(edid->data); 293​ const uint8_t *data = reinterpret_cast<uint8_t*>(edid->data);
Context not available.
505 m_edid.physicalSize = extractPhysicalSize(edid.data()); 447​ m_edid.physicalSize = extractPhysicalSize(edid.data());
506} 448​}
507 449​
450​bool DrmOutput::initPrimaryPlane()
451​{
452​ for (int i = 0; i < m_backend->planes().size(); ++i) {
453​ DrmPlane* p = m_backend->planes()[i];
454​ if (!p) {
455​ continue;
456​ }
457​ if (p->type() != DrmPlane::TypeIndex::Primary) {
458​ continue;
459​ }
460​ if (p->output()) { // Plane already has an output
461​ continue;
462​ }
463​ if (m_primaryPlane) { // Output already has a primary plane
464​ continue;
465​ }
466​ if (!p->isCrtcSupported(m_crtcId)) {
467​ continue;
468​ }
469​ p->setOutput(this);
470​ m_primaryPlane = p;
471​ qCDebug(KWIN_DRM) << "Initialized primary plane" << p->id() << "on CRTC" << m_crtcId;
472​ return true;
473​ }
474​ qCCritical(KWIN_DRM) << "Failed to initialize primary plane.";
475​ return false;
476​}
477​
478​bool DrmOutput::initCursorPlane() // TODO: Add call in init (but needs layer support in general first)
479​{
480​ for (int i = 0; i < m_backend->planes().size(); ++i) {
481​ DrmPlane* p = m_backend->planes()[i];
482​ if (!p) {
483​ continue;
484​ }
485​ if (p->type() != DrmPlane::TypeIndex::Cursor) {
486​ continue;
487​ }
488​ if (p->output()) { // Plane already has an output
489​ continue;
490​ }
491​ if (m_cursorPlane) { // Output already has a cursor plane
492​ continue;
493​ }
494​ if (!p->isCrtcSupported(m_crtcId)) {
495​ continue;
496​ }
497​ p->setOutput(this);
498​ m_cursorPlane = p;
499​ qCDebug(KWIN_DRM) << "Initialized cursor plane" << p->id() << "on CRTC" << m_crtcId;
500​ return true;
501​ }
502​ return false;
503​}
504​
508void DrmOutput::initDpms(drmModeConnector *connector) 505​void DrmOutput::initDpms(drmModeConnector *connector)
509{ 506​{
510 for (int i = 0; i < connector->count_props; ++i) { 507​ for (int i = 0; i < connector->count_props; ++i) {
Context not available.
525 return; 522​ return;
526 } 523​ }
527 if (mode == m_dpmsMode) { 524​ if (mode == m_dpmsMode) {
525​ qCDebug(KWIN_DRM) << "New DPMS mode equals old mode. DPMS unchanged.";
528 return; 526​ return;
529 } 527​ }
530 if (drmModeConnectorSetProperty(m_backend->fd(), m_connector, m_dpms->prop_id, uint64_t(mode)) != 0) { 528​
531 qCWarning(KWIN_DRM) << "Setting DPMS failed"; 529​ if (m_backend->atomicModeSetting()) {
532 return; 530​ drmModeAtomicReq *req = drmModeAtomicAlloc();
531​
532​ if (atomicReqModesetPopulate(req, mode == DpmsMode::On) == DrmObject::AtomicReturn::Error) {
533​ qCWarning(KWIN_DRM) << "Failed to populate atomic request for output" << m_crtcId;
534​ return;
535​ }
536​ if (drmModeAtomicCommit(m_backend->fd(), req, DRM_MODE_ATOMIC_ALLOW_MODESET, this)) {
537​ qCWarning(KWIN_DRM) << "Failed to commit atomic request for output" << m_crtcId;
538​ } else {
539​ qCDebug(KWIN_DRM) << "DPMS set for output" << m_crtcId;
540​ }
541​ drmModeAtomicFree(req);
542​ } else {
543​ if (drmModeConnectorSetProperty(m_backend->fd(), m_connector, m_dpms->prop_id, uint64_t(mode)) < 0) {
graesslinUnsubmitted
Done

for readability I would say

p->type() != DrmPlane::TYPE_CURSOR
graesslin: for readability I would say p->type() != DrmPlane::TYPE_CURSOR
544​ qCWarning(KWIN_DRM) << "Setting DPMS failed";
545​ return;
546​ }
533 } 547​ }
548​
534 m_dpmsMode = mode; 549​ m_dpmsMode = mode;
535 if (m_waylandOutput) { 550​ if (m_waylandOutput) {
536 m_waylandOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsMode)); 551​ m_waylandOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsMode));
graesslinUnsubmitted
Done

nitpick: coding style

graesslin: nitpick: coding style
graesslinUnsubmitted
Done

coding style

graesslin: coding style
graesslinUnsubmitted
Done

coding style

graesslin: coding style
Context not available.
621 return true; 636​ return true;
622} 637​}
623 638​
639​void DrmOutput::pageFlipped()
640​{
641​ if (m_backend->atomicModeSetting()){
642​ foreach (DrmPlane *p, m_planesFlipList) {
643​ pageFlippedBufferRemover(p->current(), p->next());
644​ p->setCurrent(p->next());
645​ p->setNext(nullptr);
646​ }
647​ m_planesFlipList.clear();
648​
649​ } else {
650​ if (!m_nextBuffer) {
651​ return;
652​ }
653​ pageFlippedBufferRemover(m_currentBuffer, m_nextBuffer);
654​ m_currentBuffer = m_nextBuffer;
655​ m_nextBuffer = nullptr;
656​ }
657​ cleanupBlackBuffer();
658​}
659​
660​void DrmOutput::pageFlippedBufferRemover(DrmBuffer *oldbuffer, DrmBuffer *newbuffer)
661​{
662​ if (newbuffer->deleteAfterPageFlip()) {
663​ if ( oldbuffer && oldbuffer != newbuffer ) {
664​ delete oldbuffer;
665​ }
666​ } else {
667​ // although oldbuffer's pointer is remapped in pageFlipped(),
668​ // we ignore the pointer completely anywhere else in this case
669​ newbuffer->releaseGbm();
670​ }
671​}
672​
673​void DrmOutput::cleanupBlackBuffer()
674​{
675​ if (m_blackBuffer) {
676​ delete m_blackBuffer;
677​ m_blackBuffer = nullptr;
678​ }
679​}
680​
681​bool DrmOutput::blank()
682​{
683​ if (!m_blackBuffer) {
684​ m_blackBuffer = m_backend->createBuffer(size());
685​ if (!m_blackBuffer->map()) {
686​ cleanupBlackBuffer();
687​ return false;
688​ }
689​ m_blackBuffer->image()->fill(Qt::black);
690​ }
691​ // TODO: Do this atomically
692​ return setModeLegacy(m_blackBuffer);
693​}
694​
695​bool DrmOutput::present(DrmBuffer *buffer)
696​{
697​ if (!buffer || buffer->bufferId() == 0) {
698​ return false;
699​ }
700​ if (m_backend->atomicModeSetting()) {
701​ return presentAtomically(buffer);
702​ } else {
703​ return presentLegacy(buffer);
704​ }
705​}
706​
707​bool DrmOutput::presentAtomically(DrmBuffer *buffer)
708​{
709​ if (!LogindIntegration::self()->isActiveSession()) {
710​ qCWarning(KWIN_DRM) << "Logind session not active.";
711​ return false;
712​ }
713​ if (m_dpmsMode != DpmsMode::On) {
714​ qCWarning(KWIN_DRM) << "No present() while screen off.";
715​ return false;
716​ }
717​ if (m_primaryPlane->next()) {
718​ qCWarning(KWIN_DRM) << "Page not yet flipped.";
719​ return false;
720​ }
721​
722​ DrmObject::AtomicReturn ret;
723​ uint32_t flags = DRM_MODE_ATOMIC_NONBLOCK | DRM_MODE_PAGE_FLIP_EVENT;
724​
725​ // TODO: throwing an exception would be really handy here! (would mean change of compile options)
726​ drmModeAtomicReq *req = drmModeAtomicAlloc();
727​ if (!req) {
728​ qCWarning(KWIN_DRM) << "DRM: couldn't allocate atomic request";
729​ delete buffer;
730​ return false;
731​ }
732​
733​ // Do we need to set a new mode first?
734​ bool doModeset = !m_primaryPlane->current();
735​ if (doModeset) {
736​ qCDebug(KWIN_DRM) << "Atomic Modeset requested";
737​
738​ if (drmModeCreatePropertyBlob(m_backend->fd(), &m_mode, sizeof(m_mode), &m_blobId)) {
739​ qCWarning(KWIN_DRM) << "Failed to create property blob";
740​ delete buffer;
741​ return false;
742​ }
743​
744​ ret = atomicReqModesetPopulate(req, true);
745​ if (ret == DrmObject::AtomicReturn::Error){
746​ drmModeAtomicFree(req);
747​ delete buffer;
748​ return false;
749​ }
750​ if (ret == DrmObject::AtomicReturn::Success) {
751​ flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
752​ }
753​ }
754​
755​ m_primaryPlane->setNext(buffer); // TODO: Later not only use the primary plane for the buffer!
756​ // i.e.: Assign planes
757​ bool anyDamage = false;
758​ foreach (DrmPlane* p, m_backend->planes()){
759​ if (p->output() != this) {
760​ continue;
761​ }
762​ ret = p->atomicReqPlanePopulate(req);
763​ if (ret == DrmObject::AtomicReturn::Error) {
764​ drmModeAtomicFree(req);
765​ m_primaryPlane->setNext(nullptr);
766​ m_planesFlipList.clear();
767​ delete buffer;
768​ return false;
769​ }
770​ if (ret == DrmObject::AtomicReturn::Success) {
771​ anyDamage = true;
772​ m_planesFlipList << p;
773​ }
774​ }
775​
776​ // no damage but force flip for atleast the primary plane anyway
777​ if (!anyDamage) {
778​ m_primaryPlane->setPropsValid(0);
779​ if (m_primaryPlane->atomicReqPlanePopulate(req) == DrmObject::AtomicReturn::Error) {
780​ drmModeAtomicFree(req);
781​ m_primaryPlane->setNext(nullptr);
782​ m_planesFlipList.clear();
783​ delete buffer;
784​ return false;
785​ }
786​ m_planesFlipList << m_primaryPlane;
787​ }
788​
789​ if (drmModeAtomicCommit(m_backend->fd(), req, flags, this)) {
790​ qCWarning(KWIN_DRM) << "Atomic request failed to commit:" << strerror(errno);
791​ drmModeAtomicFree(req);
792​ m_primaryPlane->setNext(nullptr);
793​ m_planesFlipList.clear();
794​ delete buffer;
795​ return false;
796​ }
797​
798​ if (doModeset) {
799​ m_crtc->setPropsValid(m_crtc->propsValid() | m_crtc->propsPending());
800​ m_conn->setPropsValid(m_conn->propsValid() | m_conn->propsPending());
801​ }
802​ foreach (DrmPlane* p, m_planesFlipList) {
803​ p->setPropsValid(p->propsValid() | p->propsPending());
804​ }
805​
806​ drmModeAtomicFree(req);
807​ return true;
808​}
809​
810​
811​bool DrmOutput::presentLegacy(DrmBuffer *buffer)
812​{
813​ if (m_nextBuffer) {
814​ return false;
815​ }
816​ if (!LogindIntegration::self()->isActiveSession()) {
817​ m_nextBuffer = buffer;
818​ return false;
819​ }
820​ if (m_dpmsMode != DpmsMode::On) {
821​ return false;
822​ }
823​
824​ // Do we need to set a new mode first?
825​ if (m_lastStride != buffer->stride() || m_lastGbm != buffer->isGbm()){
826​ if (!setModeLegacy(buffer))
827​ return false;
828​ }
829​ int errno_save = 0;
830​ const bool ok = drmModePageFlip(m_backend->fd(), m_crtcId, buffer->bufferId(), DRM_MODE_PAGE_FLIP_EVENT, this) == 0;
831​ if (ok) {
832​ m_nextBuffer = buffer;
833​ } else {
834​ errno_save = errno;
835​ qCWarning(KWIN_DRM) << "Page flip failed:" << strerror(errno);
836​ delete buffer;
837​ }
838​ return ok;
839​}
840​
841​bool DrmOutput::setModeLegacy(DrmBuffer *buffer)
842​{
843​ if (drmModeSetCrtc(m_backend->fd(), m_crtcId, buffer->bufferId(), 0, 0, &m_connector, 1, &m_mode) == 0) {
844​ m_lastStride = buffer->stride();
845​ m_lastGbm = buffer->isGbm();
846​ return true;
847​ } else {
848​ qCWarning(KWIN_DRM) << "Mode setting failed";
849​ return false;
850​ }
851​}
852​
853​DrmObject::AtomicReturn DrmOutput::atomicReqModesetPopulate(drmModeAtomicReq *req, bool enable)
854​{
855​ if (enable) {
856​ m_primaryPlane->setPropValue(int(DrmPlane::PropertyIndex::SrcW), m_mode.hdisplay << 16);
857​ m_primaryPlane->setPropValue(int(DrmPlane::PropertyIndex::SrcH), m_mode.vdisplay << 16);
858​ m_primaryPlane->setPropValue(int(DrmPlane::PropertyIndex::CrtcW), m_mode.hdisplay);
859​ m_primaryPlane->setPropValue(int(DrmPlane::PropertyIndex::CrtcH), m_mode.vdisplay);
860​ } else {
861​ m_primaryPlane->setPropValue(int(DrmPlane::PropertyIndex::SrcW), 0);
862​ m_primaryPlane->setPropValue(int(DrmPlane::PropertyIndex::SrcH), 0);
863​ m_primaryPlane->setPropValue(int(DrmPlane::PropertyIndex::CrtcW), 0);
864​ m_primaryPlane->setPropValue(int(DrmPlane::PropertyIndex::CrtcH), 0);
865​ }
866​
867​ int ret = 0;
868​
869​ m_crtc->setPropsPending(0);
870​ m_conn->setPropsPending(0);
871​
872​ ret |= m_conn->atomicAddProperty(req, int(DrmConnector::PropertyIndex::CrtcId), enable ? m_crtc->id() : 0);
873​ ret |= m_crtc->atomicAddProperty(req, int(DrmCrtc::PropertyIndex::ModeId), enable ? m_blobId : 0);
874​ ret |= m_crtc->atomicAddProperty(req, int(DrmCrtc::PropertyIndex::Active), enable);
875​
876​ if (ret) {
877​ qCWarning(KWIN_DRM) << "Failed to populate atomic modeset";
878​ return DrmObject::AtomicReturn::Error;
879​ }
880​ if (!m_crtc->propsPending() && !m_conn->propsPending()) {
881​ return DrmObject::AtomicReturn::NoChange;
882​ }
883​ return DrmObject::AtomicReturn::Success;
884​}
624 885​
625} 886​}
Context not available.