card: use std namespace
[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>
8 #include <xf86drm.h>
9 #include <xf86drmMode.h>
11 #include "kms++.h"
13 #ifndef DRM_CLIENT_CAP_ATOMIC
14 #define DRM_CLIENT_CAP_ATOMIC 3
15 #endif
17 using namespace std;
19 namespace kms
20 {
22 Card::Card()
23 {
24         const char *card = "/dev/dri/card0";
26         int fd = open(card, O_RDWR | O_CLOEXEC);
27         if (fd < 0)
28                 throw invalid_argument("foo");
29         m_fd = fd;
31         int r;
33         r = drmSetMaster(fd);
34         m_master = r == 0;
36         r = drmSetClientCap(m_fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
37         if (r)
38                 throw invalid_argument("foo");
40         r = drmSetClientCap(m_fd, DRM_CLIENT_CAP_ATOMIC, 1);
41         m_has_atomic = r == 0;
43         uint64_t has_dumb;
44         r = drmGetCap(fd, DRM_CAP_DUMB_BUFFER, &has_dumb);
45         if (r || !has_dumb)
46                 throw invalid_argument("foo");
48         auto res = drmModeGetResources(m_fd);
49         if (!res)
50                 throw invalid_argument("foo");
52         for (int i = 0; i < res->count_connectors; ++i) {
53                 uint32_t id = res->connectors[i];
54                 m_obmap[id] = new Connector(*this, id, i);
55         }
57         for (int i = 0; i < res->count_crtcs; ++i) {
58                 uint32_t id = res->crtcs[i];
59                 m_obmap[id] = new Crtc(*this, id, i);
60         }
62         for (int i = 0; i < res->count_encoders; ++i) {
63                 uint32_t id = res->encoders[i];
64                 m_obmap[id] = new Encoder(*this, id);
65         }
67         drmModeFreeResources(res);
69         auto planeRes = drmModeGetPlaneResources(m_fd);
71         for (uint i = 0; i < planeRes->count_planes; ++i) {
72                 uint32_t id = planeRes->planes[i];
73                 m_obmap[id] = new Plane(*this, id);
74         }
76         drmModeFreePlaneResources(planeRes);
78         // collect all possible props
79         for (auto ob : get_objects()) {
80                 auto props = drmModeObjectGetProperties(m_fd, ob->id(), ob->object_type());
82                 if (props == nullptr)
83                         continue;
85                 for (unsigned i = 0; i < props->count_props; ++i) {
86                         uint32_t prop_id = props->props[i];
88                         if (m_obmap.find(prop_id) == m_obmap.end())
89                                 m_obmap[prop_id] = new Property(*this, prop_id);
90                 }
92                 drmModeFreeObjectProperties(props);
93         }
95         for (auto pair : m_obmap)
96                 pair.second->setup();
97 }
99 Card::~Card()
101         for (auto pair : m_obmap)
102                 delete pair.second;
104         close(m_fd);
107 template <class T> static void print_obs(const map<uint32_t, DrmObject*>& obmap)
109         for (auto pair : obmap) {
110                 auto ob = pair.second;
111                 if (dynamic_cast<T*>(ob)) {
112                         ob->print_short();
113                         //ob->print_props();
114                 }
115         }
118 void Card::print_short() const
120         print_obs<Connector>(m_obmap);
121         print_obs<Encoder>(m_obmap);
122         print_obs<Crtc>(m_obmap);
123         print_obs<Plane>(m_obmap);
126 Property* Card::get_prop(const char *name) const
128         for (auto pair : m_obmap) {
129                 auto prop = dynamic_cast<Property*>(pair.second);
130                 if (!prop)
131                         continue;
133                 if (strcmp(name, prop->name()) == 0)
134                         return prop;
135         }
137         throw invalid_argument("foo");
140 Connector* Card::get_first_connected_connector() const
142         for(auto pair : m_obmap) {
143                 auto c = dynamic_cast<Connector*>(pair.second);
145                 if (c && c->connected())
146                         return c;
147         }
149         throw invalid_argument("no connected connectors");
152 DrmObject* Card::get_object(uint32_t id) const
154         return m_obmap.at(id);
157 vector<Connector*> Card::get_connectors() const
159         vector<Connector*> v;
160         for(auto pair : m_obmap) {
161                 auto p = dynamic_cast<Connector*>(pair.second);
162                 if (p)
163                         v.push_back(p);
164         }
165         return v;
168 vector<Plane*> Card::get_planes() const
170         vector<Plane*> v;
171         for(auto pair : m_obmap) {
172                 auto p = dynamic_cast<Plane*>(pair.second);
173                 if (p)
174                         v.push_back(p);
175         }
176         return v;
179 vector<DrmObject*> Card::get_objects() const
181         vector<DrmObject*> v;
182         for(auto pair : m_obmap)
183                 v.push_back(pair.second);
184         return v;
187 Crtc* Card::get_crtc_by_index(uint32_t idx) const
189         for(auto pair : m_obmap) {
190                 auto crtc = dynamic_cast<Crtc*>(pair.second);
191                 if (crtc && crtc->idx() == idx)
192                         return crtc;
193         }
194         throw invalid_argument("fob");
197 Crtc* Card::get_crtc(uint32_t id) const { return dynamic_cast<Crtc*>(get_object(id)); }
198 Encoder* Card::get_encoder(uint32_t id) const { return dynamic_cast<Encoder*>(get_object(id)); }
199 Property* Card::get_prop(uint32_t id) const { return dynamic_cast<Property*>(get_object(id)); }