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         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         }
  44
  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         }
  51
  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");
  56
  57         auto res = drmModeGetResources(m_fd);
  58         if (!res)
  59                 throw invalid_argument("Can't get card resources");
  60
  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         }
  65
  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         }
  70
  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         }
  75
  76         drmModeFreeResources(res);
  77
  78         auto planeRes = drmModeGetPlaneResources(m_fd);
  79
  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         }
  84
  85         drmModeFreePlaneResources(planeRes);
  86
  87         // collect all possible props
  88         for (auto ob : get_objects()) {
  89                 auto props = drmModeObjectGetProperties(m_fd, ob->id(), ob->object_type());
  90
  91                 if (props == nullptr)
  92                         continue;
  93
  94                 for (unsigned i = 0; i < props->count_props; ++i) {
  95                         uint32_t prop_id = props->props[i];
  96
  97                         if (m_obmap.find(prop_id) == m_obmap.end())
  98                                 m_obmap[prop_id] = new Property(*this, prop_id);
  99                 }
 100
 101                 drmModeFreeObjectProperties(props);
 102         }
 103
 104         for (auto pair : m_obmap)
 105                 pair.second->setup();
 106 }
 107
 108 Card::~Card()
 109 {
 110         restore_modes();
 111
 112         for (auto pair : m_obmap)
 113                 delete pair.second;
 114
 115         close(m_fd);
 116 }
 117
 118 void Card::restore_modes()
 119 {
 120         for (auto conn : get_connectors())
 121                 conn->restore_mode();
 122 }
 123
 124 template <class T> static void print_obs(const map<uint32_t, DrmObject*>& obmap)
 125 {
 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         }
 133 }
 134
 135 void Card::print_short() const
 136 {
 137         print_obs<Connector>(m_obmap);
 138         print_obs<Encoder>(m_obmap);
 139         print_obs<Crtc>(m_obmap);
 140         print_obs<Plane>(m_obmap);
 141 }
 142
 143 Property* Card::get_prop(const string& name) const
 144 {
 145         for (auto pair : m_obmap) {
 146                 auto prop = dynamic_cast<Property*>(pair.second);
 147                 if (!prop)
 148                         continue;
 149
 150                 if (name == prop->name())
 151                         return prop;
 152         }
 153
 154         throw invalid_argument(string("Card property ") + name + " not found");
 155 }
 156
 157 Connector* Card::get_first_connected_connector() const
 158 {
 159         for(auto pair : m_obmap) {
 160                 auto c = dynamic_cast<Connector*>(pair.second);
 161
 162                 if (c && c->connected())
 163                         return c;
 164         }
 165
 166         throw invalid_argument("no connected connectors");
 167 }
 168
 169 DrmObject* Card::get_object(uint32_t id) const
 170 {
 171         return m_obmap.at(id);
 172 }
 173
 174 vector<Connector*> Card::get_connectors() const
 175 {
 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;
 183 }
 184
 185 vector<Crtc*> Card::get_crtcs() const
 186 {
 187         vector<Crtc*> v;
 188         for(auto pair : m_obmap) {
 189                 auto p = dynamic_cast<Crtc*>(pair.second);
 190                 if (p)
 191                         v.push_back(p);
 192         }
 193         return v;
 194 }
 195
 196 vector<Plane*> Card::get_planes() const
 197 {
 198         vector<Plane*> v;
 199         for(auto pair : m_obmap) {
 200                 auto p = dynamic_cast<Plane*>(pair.second);
 201                 if (p)
 202                         v.push_back(p);
 203         }
 204         return v;
 205 }
 206
 207 vector<DrmObject*> Card::get_objects() const
 208 {
 209         vector<DrmObject*> v;
 210         for(auto pair : m_obmap)
 211                 v.push_back(pair.second);
 212         return v;
 213 }
 214
 215 Crtc* Card::get_crtc_by_index(uint32_t idx) const
 216 {
 217         for(auto pair : m_obmap) {
 218                 auto crtc = dynamic_cast<Crtc*>(pair.second);
 219                 if (crtc && crtc->idx() == idx)
 220                         return crtc;
 221         }
 222         throw invalid_argument(string("Crtc #") + to_string(idx) + " not found");
 223 }
 224
 225 Connector* Card::get_connector(uint32_t id) const { return dynamic_cast<Connector*>(get_object(id)); }
 226 Crtc* Card::get_crtc(uint32_t id) const { return dynamic_cast<Crtc*>(get_object(id)); }
 227 Encoder* Card::get_encoder(uint32_t id) const { return dynamic_cast<Encoder*>(get_object(id)); }
 228 Property* Card::get_prop(uint32_t id) const { return dynamic_cast<Property*>(get_object(id)); }
 229 Plane* Card::get_plane(uint32_t id) const { return dynamic_cast<Plane*>(get_object(id)); }
 230
 231 std::vector<kms::Pipeline> Card::get_connected_pipelines()
 232 {
 233         vector<Pipeline> outputs;
 234
 235         for (auto conn : get_connectors())
 236         {
 237                 if (conn->connected() == false)
 238                         continue;
 239
 240                 Crtc* crtc = conn->get_current_crtc();
 241
 242                 if (!crtc) {
 243                         for (auto possible : conn->get_possible_crtcs()) {
 244                                 if (find_if(outputs.begin(), outputs.end(), [possible](Pipeline out) { return out.crtc == possible; }) == outputs.end()) {
 245                                         crtc = possible;
 246                                         break;
 247                                 }
 248                         }
 249                 }
 250
 251                 if (!crtc)
 252                         throw invalid_argument(string("Connector #") +
 253                                                to_string(conn->idx()) +
 254                                                " has no possible crtcs");
 255
 256                 outputs.push_back(Pipeline { crtc, conn });
 257         }
 258
 259         return outputs;
 260 }
 261
 262 static void page_flip_handler(int fd, unsigned int frame,
 263                               unsigned int sec, unsigned int usec,
 264                               void *data)
 265 {
 266         auto handler = (PageFlipHandlerBase*)data;
 267         double time = sec + usec / 1000000.0;
 268         handler->handle_page_flip(frame, time);
 269 }
 270
 271 void Card::call_page_flip_handlers()
 272 {
 273         drmEventContext ev = {
 274                 .version = DRM_EVENT_CONTEXT_VERSION,
 275                 .vblank_handler = 0,
 276                 .page_flip_handler = page_flip_handler,
 277         };
 278
 279         drmHandleEvent(fd(), &ev);
 280 }
 281
 282 }