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 using namespace std;
  15
  16 namespace kms
  17 {
  18
  19 Card::Card()
  20 {
  21         const char *card = "/dev/dri/card0";
  22
  23         int fd = open(card, O_RDWR | O_CLOEXEC);
  24         if (fd < 0)
  25                 throw invalid_argument(string(strerror(errno)) + " opening " +
  26                                        card);
  27         m_fd = fd;
  28
  29         int r;
  30
  31         r = drmSetMaster(fd);
  32         m_master = r == 0;
  33
  34         if (getenv("LIBKMSXX_DISABLE_UNIVERSAL_PLANES") == 0) {
  35                 r = drmSetClientCap(m_fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
  36                 m_has_universal_planes = r == 0;
  37         } else {
  38                 m_has_universal_planes = false;
  39         }
  40
  41 #ifdef DRM_CLIENT_CAP_ATOMIC
  42         if (getenv("LIBKMSXX_DISABLE_ATOMIC") == 0) {
  43                 r = drmSetClientCap(m_fd, DRM_CLIENT_CAP_ATOMIC, 1);
  44                 m_has_atomic = r == 0;
  45         } else {
  46                 m_has_atomic = false;
  47         }
  48 #else
  49         m_has_atomic = false;
  50 #endif
  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                 auto ob = new Connector(*this, id, i);
  64                 m_obmap[id] = ob;
  65                 m_connectors.push_back(ob);
  66         }
  67
  68         for (int i = 0; i < res->count_crtcs; ++i) {
  69                 uint32_t id = res->crtcs[i];
  70                 auto ob = new Crtc(*this, id, i);
  71                 m_obmap[id] = ob;
  72                 m_crtcs.push_back(ob);
  73         }
  74
  75         for (int i = 0; i < res->count_encoders; ++i) {
  76                 uint32_t id = res->encoders[i];
  77                 auto ob = new Encoder(*this, id);
  78                 m_obmap[id] = ob;
  79                 m_encoders.push_back(ob);
  80         }
  81
  82         drmModeFreeResources(res);
  83
  84         auto planeRes = drmModeGetPlaneResources(m_fd);
  85
  86         for (uint i = 0; i < planeRes->count_planes; ++i) {
  87                 uint32_t id = planeRes->planes[i];
  88                 auto ob = new Plane(*this, id);
  89                 m_obmap[id] = ob;
  90                 m_planes.push_back(ob);
  91         }
  92
  93         drmModeFreePlaneResources(planeRes);
  94
  95         // collect all possible props
  96         for (auto ob : get_objects()) {
  97                 auto props = drmModeObjectGetProperties(m_fd, ob->id(), ob->object_type());
  98
  99                 if (props == nullptr)
 100                         continue;
 101
 102                 for (unsigned i = 0; i < props->count_props; ++i) {
 103                         uint32_t prop_id = props->props[i];
 104
 105                         if (m_obmap.find(prop_id) == m_obmap.end()) {
 106                                 auto ob = new Property(*this, prop_id);
 107                                 m_obmap[prop_id] = ob;
 108                                 m_properties.push_back(ob);
 109                         }
 110                 }
 111
 112                 drmModeFreeObjectProperties(props);
 113         }
 114
 115         for (auto pair : m_obmap)
 116                 pair.second->setup();
 117 }
 118
 119 Card::~Card()
 120 {
 121         restore_modes();
 122
 123         for (auto pair : m_obmap)
 124                 delete pair.second;
 125
 126         close(m_fd);
 127 }
 128
 129 void Card::restore_modes()
 130 {
 131         for (auto conn : get_connectors())
 132                 conn->restore_mode();
 133 }
 134
 135 Property* Card::get_prop(const string& name) const
 136 {
 137         for (auto prop : m_properties) {
 138                 if (name == prop->name())
 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 c : m_connectors) {
 148                 if (c->connected())
 149                         return c;
 150         }
 151
 152         throw invalid_argument("no connected connectors");
 153 }
 154
 155 DrmObject* Card::get_object(uint32_t id) const
 156 {
 157         return m_obmap.at(id);
 158 }
 159
 160 const vector<DrmObject*> Card::get_objects() const
 161 {
 162         vector<DrmObject*> v;
 163         for(auto pair : m_obmap)
 164                 v.push_back(pair.second);
 165         return v;
 166 }
 167
 168 Crtc* Card::get_crtc_by_index(uint32_t idx) const
 169 {
 170         return m_crtcs[idx];
 171 }
 172
 173 Connector* Card::get_connector(uint32_t id) const { return dynamic_cast<Connector*>(get_object(id)); }
 174 Crtc* Card::get_crtc(uint32_t id) const { return dynamic_cast<Crtc*>(get_object(id)); }
 175 Encoder* Card::get_encoder(uint32_t id) const { return dynamic_cast<Encoder*>(get_object(id)); }
 176 Property* Card::get_prop(uint32_t id) const { return dynamic_cast<Property*>(get_object(id)); }
 177 Plane* Card::get_plane(uint32_t id) const { return dynamic_cast<Plane*>(get_object(id)); }
 178
 179 std::vector<kms::Pipeline> Card::get_connected_pipelines()
 180 {
 181         vector<Pipeline> outputs;
 182
 183         for (auto conn : get_connectors())
 184         {
 185                 if (conn->connected() == false)
 186                         continue;
 187
 188                 Crtc* crtc = conn->get_current_crtc();
 189
 190                 if (!crtc) {
 191                         for (auto possible : conn->get_possible_crtcs()) {
 192                                 if (find_if(outputs.begin(), outputs.end(), [possible](Pipeline out) { return out.crtc == possible; }) == outputs.end()) {
 193                                         crtc = possible;
 194                                         break;
 195                                 }
 196                         }
 197                 }
 198
 199                 if (!crtc)
 200                         throw invalid_argument(string("Connector #") +
 201                                                to_string(conn->idx()) +
 202                                                " has no possible crtcs");
 203
 204                 outputs.push_back(Pipeline { crtc, conn });
 205         }
 206
 207         return outputs;
 208 }
 209
 210 static void page_flip_handler(int fd, unsigned int frame,
 211                               unsigned int sec, unsigned int usec,
 212                               void *data)
 213 {
 214         auto handler = (PageFlipHandlerBase*)data;
 215         double time = sec + usec / 1000000.0;
 216         handler->handle_page_flip(frame, time);
 217 }
 218
 219 void Card::call_page_flip_handlers()
 220 {
 221         drmEventContext ev = {
 222                 .version = DRM_EVENT_CONTEXT_VERSION,
 223                 .vblank_handler = 0,
 224                 .page_flip_handler = page_flip_handler,
 225         };
 226
 227         drmHandleEvent(fd(), &ev);
 228 }
 229
 230 }