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>
   8
   9 #include <xf86drm.h>
  10 #include <xf86drmMode.h>
  11
  12 #include "kms++.h"
  13
  14 #ifndef DRM_CLIENT_CAP_ATOMIC
  15 #define DRM_CLIENT_CAP_ATOMIC 3
  16 #endif
  17
  18 using namespace std;
  19
  20 namespace kms
  21 {
  22
  23 Card::Card()
  24 {
  25         const char *card = "/dev/dri/card0";
  26
  27         int fd = open(card, O_RDWR | O_CLOEXEC);
  28         if (fd < 0)
  29                 throw invalid_argument("foo");
  30         m_fd = fd;
  31
  32         int r;
  33
  34         r = drmSetMaster(fd);
  35         m_master = r == 0;
  36
  37         r = drmSetClientCap(m_fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
  38         if (r)
  39                 throw invalid_argument("foo");
  40
  41         r = drmSetClientCap(m_fd, DRM_CLIENT_CAP_ATOMIC, 1);
  42         m_has_atomic = r == 0;
  43
  44         uint64_t has_dumb;
  45         r = drmGetCap(fd, DRM_CAP_DUMB_BUFFER, &has_dumb);
  46         if (r || !has_dumb)
  47                 throw invalid_argument("foo");
  48
  49         auto res = drmModeGetResources(m_fd);
  50         if (!res)
  51                 throw invalid_argument("foo");
  52
  53         for (int i = 0; i < res->count_connectors; ++i) {
  54                 uint32_t id = res->connectors[i];
  55                 m_obmap[id] = new Connector(*this, id, i);
  56         }
  57
  58         for (int i = 0; i < res->count_crtcs; ++i) {
  59                 uint32_t id = res->crtcs[i];
  60                 m_obmap[id] = new Crtc(*this, id, i);
  61         }
  62
  63         for (int i = 0; i < res->count_encoders; ++i) {
  64                 uint32_t id = res->encoders[i];
  65                 m_obmap[id] = new Encoder(*this, id);
  66         }
  67
  68         drmModeFreeResources(res);
  69
  70         auto planeRes = drmModeGetPlaneResources(m_fd);
  71
  72         for (uint i = 0; i < planeRes->count_planes; ++i) {
  73                 uint32_t id = planeRes->planes[i];
  74                 m_obmap[id] = new Plane(*this, id);
  75         }
  76
  77         drmModeFreePlaneResources(planeRes);
  78
  79         // collect all possible props
  80         for (auto ob : get_objects()) {
  81                 auto props = drmModeObjectGetProperties(m_fd, ob->id(), ob->object_type());
  82
  83                 if (props == nullptr)
  84                         continue;
  85
  86                 for (unsigned i = 0; i < props->count_props; ++i) {
  87                         uint32_t prop_id = props->props[i];
  88
  89                         if (m_obmap.find(prop_id) == m_obmap.end())
  90                                 m_obmap[prop_id] = new Property(*this, prop_id);
  91                 }
  92
  93                 drmModeFreeObjectProperties(props);
  94         }
  95
  96         for (auto pair : m_obmap)
  97                 pair.second->setup();
  98 }
  99
 100 Card::~Card()
 101 {
 102         for (auto pair : m_obmap)
 103                 delete pair.second;
 104
 105         close(m_fd);
 106 }
 107
 108 template <class T> static void print_obs(const map<uint32_t, DrmObject*>& obmap)
 109 {
 110         for (auto pair : obmap) {
 111                 auto ob = pair.second;
 112                 if (dynamic_cast<T*>(ob)) {
 113                         ob->print_short();
 114                         //ob->print_props();
 115                 }
 116         }
 117 }
 118
 119 void Card::print_short() const
 120 {
 121         print_obs<Connector>(m_obmap);
 122         print_obs<Encoder>(m_obmap);
 123         print_obs<Crtc>(m_obmap);
 124         print_obs<Plane>(m_obmap);
 125 }
 126
 127 Property* Card::get_prop(const char *name) const
 128 {
 129         for (auto pair : m_obmap) {
 130                 auto prop = dynamic_cast<Property*>(pair.second);
 131                 if (!prop)
 132                         continue;
 133
 134                 if (strcmp(name, prop->name()) == 0)
 135                         return prop;
 136         }
 137
 138         throw invalid_argument("foo");
 139 }
 140
 141 Connector* Card::get_first_connected_connector() const
 142 {
 143         for(auto pair : m_obmap) {
 144                 auto c = dynamic_cast<Connector*>(pair.second);
 145
 146                 if (c && c->connected())
 147                         return c;
 148         }
 149
 150         throw invalid_argument("no connected connectors");
 151 }
 152
 153 DrmObject* Card::get_object(uint32_t id) const
 154 {
 155         return m_obmap.at(id);
 156 }
 157
 158 vector<Connector*> Card::get_connectors() const
 159 {
 160         vector<Connector*> v;
 161         for(auto pair : m_obmap) {
 162                 auto p = dynamic_cast<Connector*>(pair.second);
 163                 if (p)
 164                         v.push_back(p);
 165         }
 166         return v;
 167 }
 168
 169 vector<Plane*> Card::get_planes() const
 170 {
 171         vector<Plane*> v;
 172         for(auto pair : m_obmap) {
 173                 auto p = dynamic_cast<Plane*>(pair.second);
 174                 if (p)
 175                         v.push_back(p);
 176         }
 177         return v;
 178 }
 179
 180 vector<DrmObject*> Card::get_objects() const
 181 {
 182         vector<DrmObject*> v;
 183         for(auto pair : m_obmap)
 184                 v.push_back(pair.second);
 185         return v;
 186 }
 187
 188 Crtc* Card::get_crtc_by_index(uint32_t idx) const
 189 {
 190         for(auto pair : m_obmap) {
 191                 auto crtc = dynamic_cast<Crtc*>(pair.second);
 192                 if (crtc && crtc->idx() == idx)
 193                         return crtc;
 194         }
 195         throw invalid_argument("fob");
 196 }
 197
 198 Crtc* Card::get_crtc(uint32_t id) const { return dynamic_cast<Crtc*>(get_object(id)); }
 199 Encoder* Card::get_encoder(uint32_t id) const { return dynamic_cast<Encoder*>(get_object(id)); }
 200 Property* Card::get_prop(uint32_t id) const { return dynamic_cast<Property*>(get_object(id)); }
 201
 202 std::vector<kms::Pipeline> Card::get_connected_pipelines()
 203 {
 204         vector<Pipeline> outputs;
 205
 206         for (auto conn : get_connectors())
 207         {
 208                 if (conn->connected() == false)
 209                         continue;
 210
 211                 Crtc* crtc = conn->get_current_crtc();
 212
 213                 if (!crtc) {
 214                         for (auto possible : conn->get_possible_crtcs()) {
 215                                 if (find_if(outputs.begin(), outputs.end(), [possible](Pipeline out) { return out.crtc == possible; }) == outputs.end()) {
 216                                         crtc = possible;
 217                                         break;
 218                                 }
 219                         }
 220                 }
 221
 222                 if (!crtc)
 223                         throw invalid_argument("fob");
 224
 225                 outputs.push_back(Pipeline { crtc, conn });
 226         }
 227
 228         return outputs;
 229 }
 230
 231 }