Differential D2370 Diff 6176 plugins/platforms/drm/drm_object_plane.cpp

Changeset View

Standalone View

View Options

plugins/platforms/drm/drm_object_plane.cpp

  • This file was added.
1​/********************************************************************
2​ KWin - the KDE window manager
3​ This file is part of the KDE project.
4​
5​Copyright (C) 2016 Roman Gilg <subdiff@gmail.com>
6​
7​This program is free software; you can redistribute it and/or modify
8​it under the terms of the GNU General Public License as published by
9​the Free Software Foundation; either version 2 of the License, or
10​(at your option) any later version.
11​
12​This program is distributed in the hope that it will be useful,
13​but WITHOUT ANY WARRANTY; without even the implied warranty of
14​MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15​GNU General Public License for more details.
16​
17​You should have received a copy of the GNU General Public License
18​along with this program. If not, see <http://www.gnu.org/licenses/>.
19​*********************************************************************/
20​#include "drm_object_plane.h"
21​#include "drm_buffer.h"
22​#include "drm_pointer.h"
23​#include "logging.h"
24​
25​namespace KWin
26​{
27​
28​DrmPlane::DrmPlane(uint32_t plane_id, int fd)
29​ : DrmObject(plane_id, fd)
30​{
31​}
32​
33​DrmPlane::~DrmPlane() = default;
34​
35​bool DrmPlane::init()
36​{
37​ qCDebug(KWIN_DRM) << "Initialize plane" << m_id;
38​ ScopedDrmPointer<_drmModePlane, &drmModeFreePlane> p(drmModeGetPlane(m_fd, m_id));
39​
40​ if (!p) {
41​ qCWarning(KWIN_DRM) << "Failed to get kernel plane" << m_id;
42​ return false;
43​ }
44​
45​ m_possibleCrtcs = p->possible_crtcs;
46​
47​ m_formats.resize(p->count_formats);
48​ for (int i = 0; i < p->count_formats; i++) {
49​ m_formats[i] = p->formats[i];
graesslinUnsubmitted
Done

nitpick: coding style

graesslin: nitpick: coding style
50​ }
51​
52​ if (!initProps()) {
53​ return false;
54​ }
55​ return true;
56​}
57​
58​bool DrmPlane::initProps()
59​{
60​ m_propsNames = {
61​ QByteArrayLiteral("type"),
62​ QByteArrayLiteral("SRC_X"),
63​ QByteArrayLiteral("SRC_Y"),
64​ QByteArrayLiteral("SRC_W"),
65​ QByteArrayLiteral("SRC_H"),
66​ QByteArrayLiteral("CRTC_X"),
67​ QByteArrayLiteral("CRTC_Y"),
68​ QByteArrayLiteral("CRTC_W"),
69​ QByteArrayLiteral("CRTC_H"),
70​ QByteArrayLiteral("FB_ID"),
71​ QByteArrayLiteral("CRTC_ID"),
72​ };
graesslinUnsubmitted
Done

QByteArrayLiteral

graesslin: QByteArrayLiteral
73​
74​ QVector<QByteArray> typeNames = {
75​ QByteArrayLiteral("Primary"),
76​ QByteArrayLiteral("Cursor"),
77​ QByteArrayLiteral("Overlay"),
78​ };
graesslinUnsubmitted
Done

QByteArrayLiteral

graesslin: QByteArrayLiteral
79​
80​ drmModeObjectProperties *properties = drmModeObjectGetProperties(m_fd, m_id, DRM_MODE_OBJECT_PLANE);
81​ if (!properties){
82​ qCWarning(KWIN_DRM) << "Failed to get properties for plane " << m_id ;
83​ return false;
84​ }
85​
86​ int propCount = int(PropertyIndex::Count);
87​ for (int j = 0; j < propCount; ++j) {
88​ if (j == int(PropertyIndex::Type)) {
89​ initProp(j, properties, typeNames);
90​ } else {
91​ initProp(j, properties);
92​ }
93​ }
94​
95​ drmModeFreeObjectProperties(properties);
96​ return true;
97​}
98​
99​DrmPlane::TypeIndex DrmPlane::type()
100​{
101​ uint64_t value = propValue(int(PropertyIndex::Type));
102​ int typeCount = int(TypeIndex::Count);
103​ for (int i = 0; i < typeCount; i++) {
104​ if (m_props[int(PropertyIndex::Type)]->enumMap(i) == value) {
105​ return TypeIndex(i);
106​ }
107​ }
108​ return TypeIndex::Overlay;
109​}
110​
111​bool DrmPlane::isCrtcSupported(uint32_t crtc)
112​{
113​ ScopedDrmPointer<_drmModeRes, &drmModeFreeResources> res(drmModeGetResources(m_fd));
114​ if (!res) {
115​ qCWarning(KWIN_DRM) << "Failed to get drm resources";
116​ }
117​ for (int c = 0; c < res->count_crtcs; c++) {
118​ if (res->crtcs[c] != crtc) {
119​ continue;
120​ }
121​ qCDebug(KWIN_DRM) << "Mask " << m_possibleCrtcs << ", idx " << c;
graesslinUnsubmitted
Done

whitespaces

graesslin: whitespaces
122​ if (m_possibleCrtcs & (1 << c)) {
123​ return true;
124​ }
125​ }
126​ qCDebug(KWIN_DRM) << "CRTC" << crtc << "not supported";
127​ return false;
128​}
129​
130​
131​void DrmPlane::setFormats(uint32_t const *f, int fcount)
132​{
133​ m_formats.resize(fcount);
134​ for (int i = 0; i < fcount; i++) {
135​ m_formats[i] = *f;
136​ }
137​}
138​
139​DrmObject::AtomicReturn DrmPlane::atomicReqPlanePopulate(drmModeAtomicReq *req)
140​{
141​ bool ret = true;
142​
143​ if (m_next) {
144​ setPropValue(int(PropertyIndex::FbId), m_next->bufferId());
145​ } else {
146​ setPropValue(int(PropertyIndex::FbId), 0);
147​ setPropValue(int(PropertyIndex::SrcX), 0);
148​ setPropValue(int(PropertyIndex::SrcY), 0);
149​ setPropValue(int(PropertyIndex::SrcW), 0);
150​ setPropValue(int(PropertyIndex::SrcH), 0);
151​ setPropValue(int(PropertyIndex::CrtcX), 0);
152​ setPropValue(int(PropertyIndex::CrtcY), 0);
153​ setPropValue(int(PropertyIndex::CrtcW), 0);
154​ setPropValue(int(PropertyIndex::CrtcH), 0);
155​ }
156​
157​ m_propsPending = 0;
158​
159​ for (int i = int(PropertyIndex::SrcX); i < int(PropertyIndex::CrtcId); i++) {
160​ ret &= atomicAddProperty(req, i, propValue(i));
161​ }
162​ ret &= atomicAddProperty(req, int(PropertyIndex::CrtcId), m_next ? propValue(int(PropertyIndex::CrtcId)) : 0);
163​
164​ if (!ret) {
165​ qCWarning(KWIN_DRM) << "Failed to populate atomic plane" << m_id;
166​ return DrmObject::AtomicReturn::Error;
167​ }
168​ if (!m_propsPending) {
graesslinUnsubmitted
Done

is the differentiation of the return values needed? If not I suggest to go with a bool

graesslin: is the differentiation of the return values needed? If not I suggest to go with a bool
romanggAuthorUnsubmitted
Done

Yes, it's needed.

  • -1 = error, abort atomic commit
  • 0 = no error but no value needed to be changed -> don't include plane in atomic commit
  • 1 = no error and value needed to be changed -> include in atomic commit
romangg: Yes, it's needed. - -1 = error, abort atomic commit - 0 = no error but no value needed to be…
graesslinUnsubmitted
Done

ok, please return an enum value instead of int describing the values.

graesslin: ok, please return an enum value instead of int describing the values.
169​ return DrmObject::AtomicReturn::NoChange;
170​ }
171​ return DrmObject::AtomicReturn::Success;
172​}
173​
174​}