Debian Codegraph @

src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_support/qeglfskmseventreader.cpp

raw
1 // Copyright (C) 2019 The Qt Company Ltd.
2 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4 #include "qeglfskmseventreader_p.h"
5 #include "qeglfskmsdevice_p.h"
6 #include "qeglfskmsscreen_p.h"
7 #include "qeglfskmsintegration_p.h"
8
9 #include <QSocketNotifier>
10 #include <QCoreApplication>
11 #include <QLoggingCategory>
12
13 QT_BEGIN_NAMESPACE
14
15 static void pageFlipHandler(int fd, unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, void *user_data)
16 {
17 Q_UNUSED(fd);
18
19 QEglFSKmsEventReaderThread *t = static_cast<QEglFSKmsEventReaderThread *>(QThread::currentThread());
20 t->eventHost()->handlePageFlipCompleted(user_data);
21
22 QEglFSKmsScreen *screen = static_cast<QEglFSKmsScreen *>(user_data);
23 screen->pageFlipped(sequence, tv_sec, tv_usec);
24 }
25
26 class RegisterWaitFlipEvent : public QEvent
27 {
28 public:
29 static const QEvent::Type TYPE = QEvent::Type(QEvent::User + 1);
30 RegisterWaitFlipEvent(void *key, QMutex *mutex, QWaitCondition *cond)
31 : QEvent(TYPE), key(key), mutex(mutex), cond(cond)
32 { }
33 void *key;
34 QMutex *mutex;
35 QWaitCondition *cond;
36 };
37
38 bool QEglFSKmsEventHost::event(QEvent *event)
39 {
40 if (event->type() == RegisterWaitFlipEvent::TYPE) {
41 RegisterWaitFlipEvent *e = static_cast<RegisterWaitFlipEvent *>(event);
42 PendingFlipWait *p = &pendingFlipWaits[0];
43 PendingFlipWait *end = p + MAX_FLIPS;
44 while (p < end) {
45 if (!p->key) {
46 p->key = e->key;
47 p->mutex = e->mutex;
48 p->cond = e->cond;
49 updateStatus();
50 return true;
51 }
52 ++p;
53 }
54 qWarning("Cannot queue page flip wait (more than %d screens?)", MAX_FLIPS);
55 e->mutex->lock();
56 e->cond->wakeOne();
57 e->mutex->unlock();
58 return true;
59 }
60 return QObject::event(event);
61 }
62
63 void QEglFSKmsEventHost::updateStatus()
64 {
65 void **begin = &completedFlips[0];
66 void **end = begin + MAX_FLIPS;
67
68 for (int i = 0; i < MAX_FLIPS; ++i) {
69 PendingFlipWait *w = pendingFlipWaits + i;
70 if (!w->key)
71 continue;
72
73 void **p = begin;
74 while (p < end) {
75 if (*p == w->key) {
76 *p = nullptr;
77 w->key = nullptr;
78 w->mutex->lock();
79 w->cond->wakeOne();
80 w->mutex->unlock();
81 return;
82 }
83 ++p;
84 }
85 }
86 }
87
88 void QEglFSKmsEventHost::handlePageFlipCompleted(void *key)
89 {
90 void **begin = &completedFlips[0];
91 void **end = begin + MAX_FLIPS;
92 void **p = begin;
93 while (p < end) {
94 if (*p == key) {
95 updateStatus();
96 return;
97 }
98 ++p;
99 }
100 p = begin;
101 while (p < end) {
102 if (!*p) {
103 *p = key;
104 updateStatus();
105 return;
106 }
107 ++p;
108 }
109 qWarning("Cannot store page flip status (more than %d screens?)", MAX_FLIPS);
110 }
111
112 void QEglFSKmsEventReaderThread::run()
113 {
114 qCDebug(qLcEglfsKmsDebug, "Event reader thread: entering event loop");
115
116 QSocketNotifier notifier(m_fd, QSocketNotifier::Read);
117 QObject::connect(&notifier, &QSocketNotifier::activated, &notifier, [this] {
118 drmEventContext drmEvent;
119 memset(&drmEvent, 0, sizeof(drmEvent));
120 drmEvent.version = 2;
121 drmEvent.vblank_handler = nullptr;
122 drmEvent.page_flip_handler = pageFlipHandler;
123 drmHandleEvent(m_fd, &drmEvent);
124 });
125
126 exec();
127
128 m_ev.moveToThread(thread()); // move back to the thread where m_ev was created
129
130 qCDebug(qLcEglfsKmsDebug, "Event reader thread: event loop stopped");
131 }
132
133 QEglFSKmsEventReader::~QEglFSKmsEventReader()
134 {
135 destroy();
136 }
137
138 void QEglFSKmsEventReader::create(QEglFSKmsDevice *device)
139 {
140 destroy();
141
142 if (!device)
143 return;
144
145 m_device = device;
146
147 qCDebug(qLcEglfsKmsDebug, "Initializing event reader for device %p fd %d",
148 m_device, m_device->fd());
149
150 m_thread = new QEglFSKmsEventReaderThread(m_device->fd());
151 m_thread->start();
152
153 // Change thread affinity for the event host, so that postEvent()
154 // goes through the event reader thread's event loop for that object.
155 m_thread->eventHost()->moveToThread(m_thread);
156 }
157
158 void QEglFSKmsEventReader::destroy()
159 {
160 if (!m_device)
161 return;
162
163 qCDebug(qLcEglfsKmsDebug, "Stopping event reader for device %p", m_device);
164
165 if (m_thread) {
166 m_thread->quit();
167 m_thread->wait();
168 delete m_thread;
169 m_thread = nullptr;
170 }
171
172 m_device = nullptr;
173 }
174
175 void QEglFSKmsEventReader::startWaitFlip(void *key, QMutex *mutex, QWaitCondition *cond)
176 {
177 if (m_thread) {
178 QCoreApplication::postEvent(m_thread->eventHost(),
179 new RegisterWaitFlipEvent(key, mutex, cond));
180 }
181 }
182
183 QT_END_NAMESPACE