add Card::get_connector(id)
[android/external-libkmsxx.git] / libkms++ / card.cpp
1 #include <stdio.h>
2 #include <unistd.h>
3 #include <fcntl.h>
4 #include <utility>
5 #include <stdexcept>
6 #include <string.h>
7 #include <algorithm>
9 #include <xf86drm.h>
10 #include <xf86drmMode.h>
12 #include "kms++.h"
14 #ifndef DRM_CLIENT_CAP_ATOMIC
15 #define DRM_CLIENT_CAP_ATOMIC 3
16 #endif
18 using namespace std;
20 namespace kms
21 {
23 Card::Card()
24 {
25         const char *card = "/dev/dri/card0";
27         int fd = open(card, O_RDWR | O_CLOEXEC);
28         if (fd < 0)
29                 throw invalid_argument(string(strerror(errno)) + " opening " +
30                                        card);
31         m_fd = fd;
33         int r;
35         r = drmSetMaster(fd);
36         m_master = r == 0;
38         if (getenv("LIBKMSXX_DISABLE_UNIVERSAL_PLANES") == 0) {
39                 r = drmSetClientCap(m_fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
40                 m_has_universal_planes = r == 0;
41         } else {
42                 m_has_universal_planes = false;
43         }
45         if (getenv("LIBKMSXX_DISABLE_ATOMIC") == 0) {
46                 r = drmSetClientCap(m_fd, DRM_CLIENT_CAP_ATOMIC, 1);
47                 m_has_atomic = r == 0;
48         } else {
49                 m_has_atomic = false;
50         }
52         uint64_t has_dumb;
53         r = drmGetCap(fd, DRM_CAP_DUMB_BUFFER, &has_dumb);
54         if (r || !has_dumb)
55                 throw invalid_argument("Dumb buffers not available");
57         auto res = drmModeGetResources(m_fd);
58         if (!res)
59                 throw invalid_argument("Can't get card resources");
61         for (int i = 0; i < res->count_connectors; ++i) {
62                 uint32_t id = res->connectors[i];
63                 m_obmap[id] = new Connector(*this, id, i);
64         }
66         for (int i = 0; i < res->count_crtcs; ++i) {
67                 uint32_t id = res->crtcs[i];
68                 m_obmap[id] = new Crtc(*this, id, i);
69         }
71         for (int i = 0; i < res->count_encoders; ++i) {
72                 uint32_t id = res->encoders[i];
73                 m_obmap[id] = new Encoder(*this, id);
74         }
76         drmModeFreeResources(res);
78         auto planeRes = drmModeGetPlaneResources(m_fd);
80         for (uint i = 0; i < planeRes->count_planes; ++i) {
81                 uint32_t id = planeRes->planes[i];
82                 m_obmap[id] = new Plane(*this, id);
83         }
85         drmModeFreePlaneResources(planeRes);
87         // collect all possible props
88         for (auto ob : get_objects()) {
89                 auto props = drmModeObjectGetProperties(m_fd, ob->id(), ob->object_type());
91                 if (props == nullptr)
92                         continue;
94                 for (unsigned i = 0; i < props->count_props; ++i) {
95                         uint32_t prop_id = props->props[i];
97                         if (m_obmap.find(prop_id) == m_obmap.end())
98                                 m_obmap[prop_id] = new Property(*this, prop_id);
99                 }
101                 drmModeFreeObjectProperties(props);
102         }
104         for (auto pair : m_obmap)
105                 pair.second->setup();
108 Card::~Card()
110         restore_modes();
112         for (auto pair : m_obmap)
113                 delete pair.second;
115         close(m_fd);
118 void Card::restore_modes()
120         for (auto conn : get_connectors())
121                 conn->restore_mode();
124 template <class T> static void print_obs(const map<uint32_t, DrmObject*>& obmap)
126         for (auto pair : obmap) {
127                 auto ob = pair.second;
128                 if (dynamic_cast<T*>(ob)) {
129                         ob->print_short();
130                         //ob->print_props();
131                 }
132         }
135 void Card::print_short() const
137         print_obs<Connector>(m_obmap);
138         print_obs<Encoder>(m_obmap);
139         print_obs<Crtc>(m_obmap);
140         print_obs<Plane>(m_obmap);
143 Property* Card::get_prop(const string& name) const
145         for (auto pair : m_obmap) {
146                 auto prop = dynamic_cast<Property*>(pair.second);
147                 if (!prop)
148                         continue;
150                 if (name == prop->name())
151                         return prop;
152         }
154         throw invalid_argument(string("Card property ") + name + " not found");
157 Connector* Card::get_first_connected_connector() const
159         for(auto pair : m_obmap) {
160                 auto c = dynamic_cast<Connector*>(pair.second);
162                 if (c && c->connected())
163                         return c;
164         }
166         throw invalid_argument("no connected connectors");
169 DrmObject* Card::get_object(uint32_t id) const
171         return m_obmap.at(id);
174 vector<Connector*> Card::get_connectors() const
176         vector<Connector*> v;
177         for(auto pair : m_obmap) {
178                 auto p = dynamic_cast<Connector*>(pair.second);
179                 if (p)
180                         v.push_back(p);
181         }
182         return v;
185 vector<Plane*> Card::get_planes() const
187         vector<Plane*> v;
188         for(auto pair : m_obmap) {
189                 auto p = dynamic_cast<Plane*>(pair.second);
190                 if (p)
191                         v.push_back(p);
192         }
193         return v;
196 vector<DrmObject*> Card::get_objects() const
198         vector<DrmObject*> v;
199         for(auto pair : m_obmap)
200                 v.push_back(pair.second);
201         return v;
204 Crtc* Card::get_crtc_by_index(uint32_t idx) const
206         for(auto pair : m_obmap) {
207                 auto crtc = dynamic_cast<Crtc*>(pair.second);
208                 if (crtc && crtc->idx() == idx)
209                         return crtc;
210         }
211         throw invalid_argument(string("Crtc #") + to_string(idx) + " not found");
214 Connector* Card::get_connector(uint32_t id) const { return dynamic_cast<Connector*>(get_object(id)); }
215 Crtc* Card::get_crtc(uint32_t id) const { return dynamic_cast<Crtc*>(get_object(id)); }
216 Encoder* Card::get_encoder(uint32_t id) const { return dynamic_cast<Encoder*>(get_object(id)); }
217 Property* Card::get_prop(uint32_t id) const { return dynamic_cast<Property*>(get_object(id)); }
219 std::vector<kms::Pipeline> Card::get_connected_pipelines()
221         vector<Pipeline> outputs;
223         for (auto conn : get_connectors())
224         {
225                 if (conn->connected() == false)
226                         continue;
228                 Crtc* crtc = conn->get_current_crtc();
230                 if (!crtc) {
231                         for (auto possible : conn->get_possible_crtcs()) {
232                                 if (find_if(outputs.begin(), outputs.end(), [possible](Pipeline out) { return out.crtc == possible; }) == outputs.end()) {
233                                         crtc = possible;
234                                         break;
235                                 }
236                         }
237                 }
239                 if (!crtc)
240                         throw invalid_argument(string("Connector #") +
241                                                to_string(conn->idx()) +
242                                                " has no possible crtcs");
244                 outputs.push_back(Pipeline { crtc, conn });
245         }
247         return outputs;
250 static void page_flip_handler(int fd, unsigned int frame,
251                               unsigned int sec, unsigned int usec,
252                               void *data)
254         auto handler = (PageFlipHandlerBase*)data;
255         double time = sec + usec / 1000000.0;
256         handler->handle_page_flip(frame, time);
259 void Card::call_page_flip_handlers()
261         drmEventContext ev = {
262                 .version = DRM_EVENT_CONTEXT_VERSION,
263                 .vblank_handler = 0,
264                 .page_flip_handler = page_flip_handler,
265         };
267         drmHandleEvent(fd(), &ev);