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