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
   8 #include <xf86drm.h>
   9 #include <xf86drmMode.h>
  10
  11 #include "kms++.h"
  12
  13 #ifndef DRM_CLIENT_CAP_ATOMIC
  14 #define DRM_CLIENT_CAP_ATOMIC 3
  15 #endif
  16
  17 using namespace std;
  18
  19 namespace kms
  20 {
  21
  22 Card::Card()
  23 {
  24         const char *card = "/dev/dri/card0";
  25
  26         int fd = open(card, O_RDWR | O_CLOEXEC);
  27         if (fd < 0)
  28                 throw invalid_argument("foo");
  29         m_fd = fd;
  30
  31         int r;
  32
  33         r = drmSetMaster(fd);
  34         m_master = r == 0;
  35
  36         r = drmSetClientCap(m_fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
  37         if (r)
  38                 throw invalid_argument("foo");
  39
  40         r = drmSetClientCap(m_fd, DRM_CLIENT_CAP_ATOMIC, 1);
  41         m_has_atomic = r == 0;
  42
  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");
  47
  48         auto res = drmModeGetResources(m_fd);
  49         if (!res)
  50                 throw invalid_argument("foo");
  51
  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         }
  56
  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         }
  61
  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         }
  66
  67         drmModeFreeResources(res);
  68
  69         auto planeRes = drmModeGetPlaneResources(m_fd);
  70
  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         }
  75
  76         drmModeFreePlaneResources(planeRes);
  77
  78         // collect all possible props
  79         for (auto ob : get_objects()) {
  80                 auto props = drmModeObjectGetProperties(m_fd, ob->id(), ob->object_type());
  81
  82                 if (props == nullptr)
  83                         continue;
  84
  85                 for (unsigned i = 0; i < props->count_props; ++i) {
  86                         uint32_t prop_id = props->props[i];
  87
  88                         if (m_obmap.find(prop_id) == m_obmap.end())
  89                                 m_obmap[prop_id] = new Property(*this, prop_id);
  90                 }
  91
  92                 drmModeFreeObjectProperties(props);
  93         }
  94
  95         for (auto pair : m_obmap)
  96                 pair.second->setup();
  97 }
  98
  99 Card::~Card()
 100 {
 101         for (auto pair : m_obmap)
 102                 delete pair.second;
 103
 104         close(m_fd);
 105 }
 106
 107 template <class T> static void print_obs(const map<uint32_t, DrmObject*>& obmap)
 108 {
 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         }
 116 }
 117
 118 void Card::print_short() const
 119 {
 120         print_obs<Connector>(m_obmap);
 121         print_obs<Encoder>(m_obmap);
 122         print_obs<Crtc>(m_obmap);
 123         print_obs<Plane>(m_obmap);
 124 }
 125
 126 Property* Card::get_prop(const char *name) const
 127 {
 128         for (auto pair : m_obmap) {
 129                 auto prop = dynamic_cast<Property*>(pair.second);
 130                 if (!prop)
 131                         continue;
 132
 133                 if (strcmp(name, prop->name()) == 0)
 134                         return prop;
 135         }
 136
 137         throw invalid_argument("foo");
 138 }
 139
 140 Connector* Card::get_first_connected_connector() const
 141 {
 142         for(auto pair : m_obmap) {
 143                 auto c = dynamic_cast<Connector*>(pair.second);
 144
 145                 if (c && c->connected())
 146                         return c;
 147         }
 148
 149         throw invalid_argument("no connected connectors");
 150 }
 151
 152 DrmObject* Card::get_object(uint32_t id) const
 153 {
 154         return m_obmap.at(id);
 155 }
 156
 157 vector<Connector*> Card::get_connectors() const
 158 {
 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;
 166 }
 167
 168 vector<Plane*> Card::get_planes() const
 169 {
 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;
 177 }
 178
 179 vector<DrmObject*> Card::get_objects() const
 180 {
 181         vector<DrmObject*> v;
 182         for(auto pair : m_obmap)
 183                 v.push_back(pair.second);
 184         return v;
 185 }
 186
 187 Crtc* Card::get_crtc_by_index(uint32_t idx) const
 188 {
 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");
 195 }
 196
 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)); }
 200 }