src/libsystemd-terminal/grdev-drm.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright (C) 2014 David Herrmann <dh.herrmann@gmail.com>
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <fcntl.h>
  23 #include <inttypes.h>
  24 #include <libudev.h>
  25 #include <stdbool.h>
  26 #include <stdlib.h>
  27 #include <sys/ioctl.h>
  28 #include <sys/mman.h>
  29 #include <sys/types.h>
  30 #include <systemd/sd-bus.h>
  31 #include <systemd/sd-event.h>
  32 #include <unistd.h>
  33
  34 /* Yuck! DRM headers need system headers included first.. but we have to
  35  * include it before shared/missing.h to avoid redefining ioctl bits */
  36 #include <drm.h>
  37 #include <drm_fourcc.h>
  38 #include <drm_mode.h>
  39
  40 #include "bus-util.h"
  41 #include "hashmap.h"
  42 #include "grdev.h"
  43 #include "grdev-internal.h"
  44 #include "macro.h"
  45 #include "udev-util.h"
  46 #include "util.h"
  47
  48 #define GRDRM_MAX_TRIES (16)
  49
  50 typedef struct grdrm_object grdrm_object;
  51 typedef struct grdrm_plane grdrm_plane;
  52 typedef struct grdrm_connector grdrm_connector;
  53 typedef struct grdrm_encoder grdrm_encoder;
  54 typedef struct grdrm_crtc grdrm_crtc;
  55
  56 typedef struct grdrm_fb grdrm_fb;
  57 typedef struct grdrm_pipe grdrm_pipe;
  58 typedef struct grdrm_card grdrm_card;
  59 typedef struct unmanaged_card unmanaged_card;
  60 typedef struct managed_card managed_card;
  61
  62 /*
  63  * Objects
  64  */
  65
  66 enum {
  67         GRDRM_TYPE_CRTC,
  68         GRDRM_TYPE_ENCODER,
  69         GRDRM_TYPE_CONNECTOR,
  70         GRDRM_TYPE_PLANE,
  71         GRDRM_TYPE_CNT
  72 };
  73
  74 struct grdrm_object {
  75         grdrm_card *card;
  76         uint32_t id;
  77         uint32_t index;
  78         unsigned int type;
  79         void (*free_fn) (grdrm_object *object);
  80
  81         bool present : 1;
  82         bool assigned : 1;
  83 };
  84
  85 struct grdrm_plane {
  86         grdrm_object object;
  87
  88         struct {
  89                 uint32_t used_crtc;
  90                 uint32_t used_fb;
  91                 uint32_t gamma_size;
  92
  93                 uint32_t n_crtcs;
  94                 uint32_t max_crtcs;
  95                 uint32_t *crtcs;
  96                 uint32_t n_formats;
  97                 uint32_t max_formats;
  98                 uint32_t *formats;
  99         } kern;
 100 };
 101
 102 struct grdrm_connector {
 103         grdrm_object object;
 104
 105         struct {
 106                 uint32_t type;
 107                 uint32_t type_id;
 108                 uint32_t used_encoder;
 109                 uint32_t connection;
 110                 uint32_t mm_width;
 111                 uint32_t mm_height;
 112                 uint32_t subpixel;
 113
 114                 uint32_t n_encoders;
 115                 uint32_t max_encoders;
 116                 uint32_t *encoders;
 117                 uint32_t n_modes;
 118                 uint32_t max_modes;
 119                 struct drm_mode_modeinfo *modes;
 120                 uint32_t n_props;
 121                 uint32_t max_props;
 122                 uint32_t *prop_ids;
 123                 uint64_t *prop_values;
 124         } kern;
 125 };
 126
 127 struct grdrm_encoder {
 128         grdrm_object object;
 129
 130         struct {
 131                 uint32_t type;
 132                 uint32_t used_crtc;
 133
 134                 uint32_t n_crtcs;
 135                 uint32_t max_crtcs;
 136                 uint32_t *crtcs;
 137                 uint32_t n_clones;
 138                 uint32_t max_clones;
 139                 uint32_t *clones;
 140         } kern;
 141 };
 142
 143 struct grdrm_crtc {
 144         grdrm_object object;
 145
 146         struct {
 147                 uint32_t used_fb;
 148                 uint32_t fb_offset_x;
 149                 uint32_t fb_offset_y;
 150                 uint32_t gamma_size;
 151
 152                 uint32_t n_used_connectors;
 153                 uint32_t max_used_connectors;
 154                 uint32_t *used_connectors;
 155
 156                 bool mode_set;
 157                 struct drm_mode_modeinfo mode;
 158         } kern;
 159
 160         struct {
 161                 bool set;
 162                 uint32_t fb;
 163                 uint32_t fb_x;
 164                 uint32_t fb_y;
 165                 uint32_t gamma;
 166
 167                 uint32_t n_connectors;
 168                 uint32_t *connectors;
 169
 170                 bool mode_set;
 171                 struct drm_mode_modeinfo mode;
 172         } old;
 173
 174         struct {
 175                 struct drm_mode_modeinfo mode;
 176                 uint32_t n_connectors;
 177                 uint32_t max_connectors;
 178                 uint32_t *connectors;
 179         } set;
 180
 181         grdrm_pipe *pipe;
 182
 183         bool applied : 1;
 184 };
 185
 186 #define GRDRM_OBJECT_INIT(_card, _id, _index, _type, _free_fn) ((grdrm_object){ \
 187                 .card = (_card), \
 188                 .id = (_id), \
 189                 .index = (_index), \
 190                 .type = (_type), \
 191                 .free_fn = (_free_fn), \
 192         })
 193
 194 grdrm_object *grdrm_find_object(grdrm_card *card, uint32_t id);
 195 int grdrm_object_add(grdrm_object *object);
 196 grdrm_object *grdrm_object_free(grdrm_object *object);
 197
 198 DEFINE_TRIVIAL_CLEANUP_FUNC(grdrm_object*, grdrm_object_free);
 199
 200 int grdrm_plane_new(grdrm_plane **out, grdrm_card *card, uint32_t id, uint32_t index);
 201 int grdrm_connector_new(grdrm_connector **out, grdrm_card *card, uint32_t id, uint32_t index);
 202 int grdrm_encoder_new(grdrm_encoder **out, grdrm_card *card, uint32_t id, uint32_t index);
 203 int grdrm_crtc_new(grdrm_crtc **out, grdrm_card *card, uint32_t id, uint32_t index);
 204
 205 #define plane_from_object(_obj) container_of((_obj), grdrm_plane, object)
 206 #define connector_from_object(_obj) container_of((_obj), grdrm_connector, object)
 207 #define encoder_from_object(_obj) container_of((_obj), grdrm_encoder, object)
 208 #define crtc_from_object(_obj) container_of((_obj), grdrm_crtc, object)
 209
 210 /*
 211  * Framebuffers
 212  */
 213
 214 struct grdrm_fb {
 215         grdev_fb base;
 216         grdrm_card *card;
 217         uint32_t id;
 218         uint32_t handles[4];
 219         uint32_t offsets[4];
 220         uint32_t sizes[4];
 221         uint32_t flipid;
 222 };
 223
 224 static int grdrm_fb_new(grdrm_fb **out, grdrm_card *card, const struct drm_mode_modeinfo *mode);
 225 grdrm_fb *grdrm_fb_free(grdrm_fb *fb);
 226
 227 DEFINE_TRIVIAL_CLEANUP_FUNC(grdrm_fb*, grdrm_fb_free);
 228
 229 #define fb_from_base(_fb) container_of((_fb), grdrm_fb, base)
 230
 231 /*
 232  * Pipes
 233  */
 234
 235 struct grdrm_pipe {
 236         grdev_pipe base;
 237         grdrm_crtc *crtc;
 238         uint32_t counter;
 239 };
 240
 241 #define grdrm_pipe_from_base(_e) container_of((_e), grdrm_pipe, base)
 242
 243 #define GRDRM_PIPE_NAME_MAX (GRDRM_CARD_NAME_MAX + 1 + DECIMAL_STR_MAX(uint32_t))
 244
 245 static const grdev_pipe_vtable grdrm_pipe_vtable;
 246
 247 static int grdrm_pipe_new(grdrm_pipe **out, grdrm_crtc *crtc, struct drm_mode_modeinfo *mode, size_t n_fbs);
 248
 249 /*
 250  * Cards
 251  */
 252
 253 struct grdrm_card {
 254         grdev_card base;
 255
 256         int fd;
 257         sd_event_source *fd_src;
 258
 259         uint32_t n_crtcs;
 260         uint32_t n_encoders;
 261         uint32_t n_connectors;
 262         uint32_t n_planes;
 263         uint32_t max_ids;
 264         Hashmap *object_map;
 265
 266         bool async_hotplug : 1;
 267         bool hotplug : 1;
 268         bool running : 1;
 269         bool ready : 1;
 270         bool cap_dumb : 1;
 271         bool cap_monotonic : 1;
 272 };
 273
 274 struct unmanaged_card {
 275         grdrm_card card;
 276         char *devnode;
 277 };
 278
 279 struct managed_card {
 280         grdrm_card card;
 281         dev_t devnum;
 282
 283         sd_bus_slot *slot_pause_device;
 284         sd_bus_slot *slot_resume_device;
 285         sd_bus_slot *slot_take_device;
 286
 287         bool requested : 1;             /* TakeDevice() was sent */
 288         bool acquired : 1;              /* TakeDevice() was successful */
 289         bool master : 1;                /* we are DRM-Master */
 290 };
 291
 292 #define grdrm_card_from_base(_e) container_of((_e), grdrm_card, base)
 293 #define unmanaged_card_from_base(_e) \
 294         container_of(grdrm_card_from_base(_e), unmanaged_card, card)
 295 #define managed_card_from_base(_e) \
 296         container_of(grdrm_card_from_base(_e), managed_card, card)
 297
 298 #define GRDRM_CARD_INIT(_vtable, _session) ((grdrm_card){ \
 299                 .base = GRDEV_CARD_INIT((_vtable), (_session)), \
 300                 .fd = -1, \
 301                 .max_ids = 32, \
 302         })
 303
 304 #define GRDRM_CARD_NAME_MAX (6 + DECIMAL_STR_MAX(unsigned) * 2)
 305
 306 static const grdev_card_vtable unmanaged_card_vtable;
 307 static const grdev_card_vtable managed_card_vtable;
 308
 309 static int grdrm_card_open(grdrm_card *card, int dev_fd);
 310 static void grdrm_card_close(grdrm_card *card);
 311 static bool grdrm_card_async(grdrm_card *card, int r);
 312
 313 /*
 314  * The page-flip event of the kernel provides 64bit of arbitrary user-data. As
 315  * drivers tend to drop events on intermediate deep mode-sets or because we
 316  * might receive events during session activation, we try to avoid allocaing
 317  * dynamic data on those events. Instead, we safe the CRTC id plus a 32bit
 318  * counter in there. This way, we only get 32bit counters, not 64bit, but that
 319  * should be more than enough. On the bright side, we no longer care whether we
 320  * lose events. No memory leaks will occur.
 321  * Modern DRM drivers might be fixed to no longer leak events, but we want to
 322  * be safe. And associating dynamically allocated data with those events is
 323  * kinda ugly, anyway.
 324  */
 325
 326 static uint64_t grdrm_encode_vblank_data(uint32_t id, uint32_t counter) {
 327         return id | ((uint64_t)counter << 32);
 328 }
 329
 330 static void grdrm_decode_vblank_data(uint64_t data, uint32_t *out_id, uint32_t *out_counter) {
 331         if (out_id)
 332                 *out_id = data & 0xffffffffU;
 333         if (out_counter)
 334                 *out_counter = (data >> 32) & 0xffffffffU;
 335 }
 336
 337 static bool grdrm_modes_compatible(const struct drm_mode_modeinfo *a, const struct drm_mode_modeinfo *b) {
 338         assert(a);
 339         assert(b);
 340
 341         /* Test whether both modes are compatible according to our internal
 342          * assumptions on modes. This comparison is highly dependent on how
 343          * we treat modes in grdrm. If we export mode details, we need to
 344          * make this comparison much stricter. */
 345
 346         if (a->hdisplay != b->hdisplay)
 347                 return false;
 348         if (a->vdisplay != b->vdisplay)
 349                 return false;
 350         if (a->vrefresh != b->vrefresh)
 351                 return false;
 352
 353         return true;
 354 }
 355
 356 /*
 357  * Objects
 358  */
 359
 360 grdrm_object *grdrm_find_object(grdrm_card *card, uint32_t id) {
 361         assert_return(card, NULL);
 362
 363         return id > 0 ? hashmap_get(card->object_map, UINT32_TO_PTR(id)) : NULL;
 364 }
 365
 366 int grdrm_object_add(grdrm_object *object) {
 367         int r;
 368
 369         assert(object);
 370         assert(object->card);
 371         assert(object->id > 0);
 372         assert(IN_SET(object->type, GRDRM_TYPE_CRTC, GRDRM_TYPE_ENCODER, GRDRM_TYPE_CONNECTOR, GRDRM_TYPE_PLANE));
 373         assert(object->free_fn);
 374
 375         if (object->index >= 32)
 376                 log_debug("grdrm: %s: object index exceeds 32bit masks: type=%u, index=%" PRIu32,
 377                           object->card->base.name, object->type, object->index);
 378
 379         r = hashmap_put(object->card->object_map, UINT32_TO_PTR(object->id), object);
 380         if (r < 0)
 381                 return r;
 382
 383         return 0;
 384 }
 385
 386 grdrm_object *grdrm_object_free(grdrm_object *object) {
 387         if (!object)
 388                 return NULL;
 389
 390         assert(object->card);
 391         assert(object->id > 0);
 392         assert(IN_SET(object->type, GRDRM_TYPE_CRTC, GRDRM_TYPE_ENCODER, GRDRM_TYPE_CONNECTOR, GRDRM_TYPE_PLANE));
 393         assert(object->free_fn);
 394
 395         hashmap_remove_value(object->card->object_map, UINT32_TO_PTR(object->id), object);
 396
 397         object->free_fn(object);
 398         return NULL;
 399 }
 400
 401 /*
 402  * Planes
 403  */
 404
 405 static void plane_free(grdrm_object *object) {
 406         grdrm_plane *plane = plane_from_object(object);
 407
 408         free(plane->kern.formats);
 409         free(plane->kern.crtcs);
 410         free(plane);
 411 }
 412
 413 int grdrm_plane_new(grdrm_plane **out, grdrm_card *card, uint32_t id, uint32_t index) {
 414         _cleanup_(grdrm_object_freep) grdrm_object *object = NULL;
 415         grdrm_plane *plane;
 416         int r;
 417
 418         assert(card);
 419
 420         plane = new0(grdrm_plane, 1);
 421         if (!plane)
 422                 return -ENOMEM;
 423
 424         object = &plane->object;
 425         *object = GRDRM_OBJECT_INIT(card, id, index, GRDRM_TYPE_PLANE, plane_free);
 426
 427         plane->kern.max_crtcs = 32;
 428         plane->kern.crtcs = new0(uint32_t, plane->kern.max_crtcs);
 429         if (!plane->kern.crtcs)
 430                 return -ENOMEM;
 431
 432         plane->kern.max_formats = 32;
 433         plane->kern.formats = new0(uint32_t, plane->kern.max_formats);
 434         if (!plane->kern.formats)
 435                 return -ENOMEM;
 436
 437         r = grdrm_object_add(object);
 438         if (r < 0)
 439                 return r;
 440
 441         if (out)
 442                 *out = plane;
 443         object = NULL;
 444         return 0;
 445 }
 446
 447 static int grdrm_plane_resync(grdrm_plane *plane) {
 448         grdrm_card *card = plane->object.card;
 449         size_t tries;
 450         int r;
 451
 452         assert(plane);
 453
 454         for (tries = 0; tries < GRDRM_MAX_TRIES; ++tries) {
 455                 struct drm_mode_get_plane res;
 456                 grdrm_object *object;
 457                 bool resized = false;
 458                 Iterator iter;
 459
 460                 zero(res);
 461                 res.plane_id = plane->object.id;
 462                 res.format_type_ptr = PTR_TO_UINT64(plane->kern.formats);
 463                 res.count_format_types = plane->kern.max_formats;
 464
 465                 r = ioctl(card->fd, DRM_IOCTL_MODE_GETPLANE, &res);
 466                 if (r < 0) {
 467                         r = -errno;
 468                         if (r == -ENOENT) {
 469                                 card->async_hotplug = true;
 470                                 r = 0;
 471                                 log_debug("grdrm: %s: plane %u removed during resync", card->base.name, plane->object.id);
 472                         } else {
 473                                 log_debug("grdrm: %s: cannot retrieve plane %u: %m", card->base.name, plane->object.id);
 474                         }
 475
 476                         return r;
 477                 }
 478
 479                 plane->kern.n_crtcs = 0;
 480                 memzero(plane->kern.crtcs, sizeof(uint32_t) * plane->kern.max_crtcs);
 481
 482                 HASHMAP_FOREACH(object, card->object_map, iter) {
 483                         if (object->type != GRDRM_TYPE_CRTC || object->index >= 32)
 484                                 continue;
 485                         if (!(res.possible_crtcs & (1 << object->index)))
 486                                 continue;
 487                         if (plane->kern.n_crtcs >= 32) {
 488                                 log_debug("grdrm: %s: possible_crtcs of plane %" PRIu32 " exceeds 32bit mask",
 489                                           card->base.name, plane->object.id);
 490                                 continue;
 491                         }
 492
 493                         plane->kern.crtcs[plane->kern.n_crtcs++] = object->id;
 494                 }
 495
 496                 if (res.count_format_types > plane->kern.max_formats) {
 497                         uint32_t max, *t;
 498
 499                         max = ALIGN_POWER2(res.count_format_types);
 500                         if (!max || max > UINT16_MAX) {
 501                                 log_debug("grdrm: %s: excessive plane resource limit: %" PRIu32, card->base.name, max);
 502                                 return -ERANGE;
 503                         }
 504
 505                         t = realloc(plane->kern.formats, sizeof(*t) * max);
 506                         if (!t)
 507                                 return -ENOMEM;
 508
 509                         plane->kern.formats = t;
 510                         plane->kern.max_formats = max;
 511                         resized = true;
 512                 }
 513
 514                 if (resized)
 515                         continue;
 516
 517                 plane->kern.n_formats = res.count_format_types;
 518                 plane->kern.used_crtc = res.crtc_id;
 519                 plane->kern.used_fb = res.fb_id;
 520                 plane->kern.gamma_size = res.gamma_size;
 521
 522                 break;
 523         }
 524
 525         if (tries >= GRDRM_MAX_TRIES) {
 526                 log_debug("grdrm: %s: plane %u not settled for retrieval", card->base.name, plane->object.id);
 527                 return -EFAULT;
 528         }
 529
 530         return 0;
 531 }
 532
 533 /*
 534  * Connectors
 535  */
 536
 537 static void connector_free(grdrm_object *object) {
 538         grdrm_connector *connector = connector_from_object(object);
 539
 540         free(connector->kern.prop_values);
 541         free(connector->kern.prop_ids);
 542         free(connector->kern.modes);
 543         free(connector->kern.encoders);
 544         free(connector);
 545 }
 546
 547 int grdrm_connector_new(grdrm_connector **out, grdrm_card *card, uint32_t id, uint32_t index) {
 548         _cleanup_(grdrm_object_freep) grdrm_object *object = NULL;
 549         grdrm_connector *connector;
 550         int r;
 551
 552         assert(card);
 553
 554         connector = new0(grdrm_connector, 1);
 555         if (!connector)
 556                 return -ENOMEM;
 557
 558         object = &connector->object;
 559         *object = GRDRM_OBJECT_INIT(card, id, index, GRDRM_TYPE_CONNECTOR, connector_free);
 560
 561         connector->kern.max_encoders = 32;
 562         connector->kern.encoders = new0(uint32_t, connector->kern.max_encoders);
 563         if (!connector->kern.encoders)
 564                 return -ENOMEM;
 565
 566         connector->kern.max_modes = 32;
 567         connector->kern.modes = new0(struct drm_mode_modeinfo, connector->kern.max_modes);
 568         if (!connector->kern.modes)
 569                 return -ENOMEM;
 570
 571         connector->kern.max_props = 32;
 572         connector->kern.prop_ids = new0(uint32_t, connector->kern.max_props);
 573         connector->kern.prop_values = new0(uint64_t, connector->kern.max_props);
 574         if (!connector->kern.prop_ids || !connector->kern.prop_values)
 575                 return -ENOMEM;
 576
 577         r = grdrm_object_add(object);
 578         if (r < 0)
 579                 return r;
 580
 581         if (out)
 582                 *out = connector;
 583         object = NULL;
 584         return 0;
 585 }
 586
 587 static int grdrm_connector_resync(grdrm_connector *connector) {
 588         grdrm_card *card = connector->object.card;
 589         size_t tries;
 590         int r;
 591
 592         assert(connector);
 593
 594         for (tries = 0; tries < GRDRM_MAX_TRIES; ++tries) {
 595                 struct drm_mode_get_connector res;
 596                 bool resized = false;
 597                 uint32_t max;
 598
 599                 zero(res);
 600                 res.connector_id = connector->object.id;
 601                 res.encoders_ptr = PTR_TO_UINT64(connector->kern.encoders);
 602                 res.props_ptr = PTR_TO_UINT64(connector->kern.prop_ids);
 603                 res.prop_values_ptr = PTR_TO_UINT64(connector->kern.prop_values);
 604                 res.count_encoders = connector->kern.max_encoders;
 605                 res.count_props = connector->kern.max_props;
 606
 607                 /* The kernel reads modes from the EDID information only if we
 608                  * pass count_modes==0. This is a legacy hack for libdrm (which
 609                  * called every ioctl twice). Now we have to adopt.. *sigh*.
 610                  * If we never received an hotplug event, there's no reason to
 611                  * sync modes. EDID reads are heavy, so skip that if not
 612                  * required. */
 613                 if (card->hotplug) {
 614                         if (tries > 0) {
 615                                 res.modes_ptr = PTR_TO_UINT64(connector->kern.modes);
 616                                 res.count_modes = connector->kern.max_modes;
 617                         } else {
 618                                 resized = true;
 619                         }
 620                 }
 621
 622                 r = ioctl(card->fd, DRM_IOCTL_MODE_GETCONNECTOR, &res);
 623                 if (r < 0) {
 624                         r = -errno;
 625                         if (r == -ENOENT) {
 626                                 card->async_hotplug = true;
 627                                 r = 0;
 628                                 log_debug("grdrm: %s: connector %u removed during resync", card->base.name, connector->object.id);
 629                         } else {
 630                                 log_debug("grdrm: %s: cannot retrieve connector %u: %m", card->base.name, connector->object.id);
 631                         }
 632
 633                         return r;
 634                 }
 635
 636                 if (res.count_encoders > connector->kern.max_encoders) {
 637                         uint32_t *t;
 638
 639                         max = ALIGN_POWER2(res.count_encoders);
 640                         if (!max || max > UINT16_MAX) {
 641                                 log_debug("grdrm: %s: excessive connector resource limit: %" PRIu32, card->base.name, max);
 642                                 return -ERANGE;
 643                         }
 644
 645                         t = realloc(connector->kern.encoders, sizeof(*t) * max);
 646                         if (!t)
 647                                 return -ENOMEM;
 648
 649                         connector->kern.encoders = t;
 650                         connector->kern.max_encoders = max;
 651                         resized = true;
 652                 }
 653
 654                 if (res.count_modes > connector->kern.max_modes) {
 655                         struct drm_mode_modeinfo *t;
 656
 657                         max = ALIGN_POWER2(res.count_modes);
 658                         if (!max || max > UINT16_MAX) {
 659                                 log_debug("grdrm: %s: excessive connector resource limit: %" PRIu32, card->base.name, max);
 660                                 return -ERANGE;
 661                         }
 662
 663                         t = realloc(connector->kern.modes, sizeof(*t) * max);
 664                         if (!t)
 665                                 return -ENOMEM;
 666
 667                         connector->kern.modes = t;
 668                         connector->kern.max_modes = max;
 669                         resized = true;
 670                 }
 671
 672                 if (res.count_props > connector->kern.max_props) {
 673                         uint32_t *tids;
 674                         uint64_t *tvals;
 675
 676                         max = ALIGN_POWER2(res.count_props);
 677                         if (!max || max > UINT16_MAX) {
 678                                 log_debug("grdrm: %s: excessive connector resource limit: %" PRIu32, card->base.name, max);
 679                                 return -ERANGE;
 680                         }
 681
 682                         tids = realloc(connector->kern.prop_ids, sizeof(*tids) * max);
 683                         if (!tids)
 684                                 return -ENOMEM;
 685                         connector->kern.prop_ids = tids;
 686
 687                         tvals = realloc(connector->kern.prop_values, sizeof(*tvals) * max);
 688                         if (!tvals)
 689                                 return -ENOMEM;
 690                         connector->kern.prop_values = tvals;
 691
 692                         connector->kern.max_props = max;
 693                         resized = true;
 694                 }
 695
 696                 if (resized)
 697                         continue;
 698
 699                 connector->kern.n_encoders = res.count_encoders;
 700                 connector->kern.n_props = res.count_props;
 701                 connector->kern.type = res.connector_type;
 702                 connector->kern.type_id = res.connector_type_id;
 703                 connector->kern.used_encoder = res.encoder_id;
 704                 connector->kern.connection = res.connection;
 705                 connector->kern.mm_width = res.mm_width;
 706                 connector->kern.mm_height = res.mm_height;
 707                 connector->kern.subpixel = res.subpixel;
 708                 if (res.modes_ptr == PTR_TO_UINT64(connector->kern.modes))
 709                         connector->kern.n_modes = res.count_modes;
 710
 711                 break;
 712         }
 713
 714         if (tries >= GRDRM_MAX_TRIES) {
 715                 log_debug("grdrm: %s: connector %u not settled for retrieval", card->base.name, connector->object.id);
 716                 return -EFAULT;
 717         }
 718
 719         return 0;
 720 }
 721
 722 /*
 723  * Encoders
 724  */
 725
 726 static void encoder_free(grdrm_object *object) {
 727         grdrm_encoder *encoder = encoder_from_object(object);
 728
 729         free(encoder->kern.clones);
 730         free(encoder->kern.crtcs);
 731         free(encoder);
 732 }
 733
 734 int grdrm_encoder_new(grdrm_encoder **out, grdrm_card *card, uint32_t id, uint32_t index) {
 735         _cleanup_(grdrm_object_freep) grdrm_object *object = NULL;
 736         grdrm_encoder *encoder;
 737         int r;
 738
 739         assert(card);
 740
 741         encoder = new0(grdrm_encoder, 1);
 742         if (!encoder)
 743                 return -ENOMEM;
 744
 745         object = &encoder->object;
 746         *object = GRDRM_OBJECT_INIT(card, id, index, GRDRM_TYPE_ENCODER, encoder_free);
 747
 748         encoder->kern.max_crtcs = 32;
 749         encoder->kern.crtcs = new0(uint32_t, encoder->kern.max_crtcs);
 750         if (!encoder->kern.crtcs)
 751                 return -ENOMEM;
 752
 753         encoder->kern.max_clones = 32;
 754         encoder->kern.clones = new0(uint32_t, encoder->kern.max_clones);
 755         if (!encoder->kern.clones)
 756                 return -ENOMEM;
 757
 758         r = grdrm_object_add(object);
 759         if (r < 0)
 760                 return r;
 761
 762         if (out)
 763                 *out = encoder;
 764         object = NULL;
 765         return 0;
 766 }
 767
 768 static int grdrm_encoder_resync(grdrm_encoder *encoder) {
 769         grdrm_card *card = encoder->object.card;
 770         struct drm_mode_get_encoder res;
 771         grdrm_object *object;
 772         Iterator iter;
 773         int r;
 774
 775         assert(encoder);
 776
 777         zero(res);
 778         res.encoder_id = encoder->object.id;
 779
 780         r = ioctl(card->fd, DRM_IOCTL_MODE_GETENCODER, &res);
 781         if (r < 0) {
 782                 r = -errno;
 783                 if (r == -ENOENT) {
 784                         card->async_hotplug = true;
 785                         r = 0;
 786                         log_debug("grdrm: %s: encoder %u removed during resync", card->base.name, encoder->object.id);
 787                 } else {
 788                         log_debug("grdrm: %s: cannot retrieve encoder %u: %m", card->base.name, encoder->object.id);
 789                 }
 790
 791                 return r;
 792         }
 793
 794         encoder->kern.type = res.encoder_type;
 795         encoder->kern.used_crtc = res.crtc_id;
 796
 797         encoder->kern.n_crtcs = 0;
 798         memzero(encoder->kern.crtcs, sizeof(uint32_t) * encoder->kern.max_crtcs);
 799
 800         HASHMAP_FOREACH(object, card->object_map, iter) {
 801                 if (object->type != GRDRM_TYPE_CRTC || object->index >= 32)
 802                         continue;
 803                 if (!(res.possible_crtcs & (1 << object->index)))
 804                         continue;
 805                 if (encoder->kern.n_crtcs >= 32) {
 806                         log_debug("grdrm: %s: possible_crtcs exceeds 32bit mask", card->base.name);
 807                         continue;
 808                 }
 809
 810                 encoder->kern.crtcs[encoder->kern.n_crtcs++] = object->id;
 811         }
 812
 813         encoder->kern.n_clones = 0;
 814         memzero(encoder->kern.clones, sizeof(uint32_t) * encoder->kern.max_clones);
 815
 816         HASHMAP_FOREACH(object, card->object_map, iter) {
 817                 if (object->type != GRDRM_TYPE_ENCODER || object->index >= 32)
 818                         continue;
 819                 if (!(res.possible_clones & (1 << object->index)))
 820                         continue;
 821                 if (encoder->kern.n_clones >= 32) {
 822                         log_debug("grdrm: %s: possible_encoders exceeds 32bit mask", card->base.name);
 823                         continue;
 824                 }
 825
 826                 encoder->kern.clones[encoder->kern.n_clones++] = object->id;
 827         }
 828
 829         return 0;
 830 }
 831
 832 /*
 833  * Crtcs
 834  */
 835
 836 static void crtc_free(grdrm_object *object) {
 837         grdrm_crtc *crtc = crtc_from_object(object);
 838
 839         if (crtc->pipe)
 840                 grdev_pipe_free(&crtc->pipe->base);
 841         free(crtc->set.connectors);
 842         free(crtc->old.connectors);
 843         free(crtc->kern.used_connectors);
 844         free(crtc);
 845 }
 846
 847 int grdrm_crtc_new(grdrm_crtc **out, grdrm_card *card, uint32_t id, uint32_t index) {
 848         _cleanup_(grdrm_object_freep) grdrm_object *object = NULL;
 849         grdrm_crtc *crtc;
 850         int r;
 851
 852         assert(card);
 853
 854         crtc = new0(grdrm_crtc, 1);
 855         if (!crtc)
 856                 return -ENOMEM;
 857
 858         object = &crtc->object;
 859         *object = GRDRM_OBJECT_INIT(card, id, index, GRDRM_TYPE_CRTC, crtc_free);
 860
 861         crtc->kern.max_used_connectors = 32;
 862         crtc->kern.used_connectors = new0(uint32_t, crtc->kern.max_used_connectors);
 863         if (!crtc->kern.used_connectors)
 864                 return -ENOMEM;
 865
 866         crtc->old.connectors = new0(uint32_t, crtc->kern.max_used_connectors);
 867         if (!crtc->old.connectors)
 868                 return -ENOMEM;
 869
 870         r = grdrm_object_add(object);
 871         if (r < 0)
 872                 return r;
 873
 874         if (out)
 875                 *out = crtc;
 876         object = NULL;
 877         return 0;
 878 }
 879
 880 static int grdrm_crtc_resync(grdrm_crtc *crtc) {
 881         grdrm_card *card = crtc->object.card;
 882         struct drm_mode_crtc res = { .crtc_id = crtc->object.id };
 883         int r;
 884
 885         assert(crtc);
 886
 887         /* make sure we can cache any combination later */
 888         if (card->n_connectors > crtc->kern.max_used_connectors) {
 889                 uint32_t max, *t;
 890
 891                 max = ALIGN_POWER2(card->n_connectors);
 892                 if (!max)
 893                         return -ENOMEM;
 894
 895                 t = realloc_multiply(crtc->kern.used_connectors, sizeof(*t), max);
 896                 if (!t)
 897                         return -ENOMEM;
 898
 899                 crtc->kern.used_connectors = t;
 900                 crtc->kern.max_used_connectors = max;
 901
 902                 if (!crtc->old.set) {
 903                         crtc->old.connectors = calloc(sizeof(*t), max);
 904                         if (!crtc->old.connectors)
 905                                 return -ENOMEM;
 906                 }
 907         }
 908
 909         /* GETCRTC doesn't return connectors. We have to read all
 910          * encoder-state and deduce the setup ourselves.. */
 911         crtc->kern.n_used_connectors = 0;
 912
 913         r = ioctl(card->fd, DRM_IOCTL_MODE_GETCRTC, &res);
 914         if (r < 0) {
 915                 r = -errno;
 916                 if (r == -ENOENT) {
 917                         card->async_hotplug = true;
 918                         r = 0;
 919                         log_debug("grdrm: %s: crtc %u removed during resync", card->base.name, crtc->object.id);
 920                 } else {
 921                         log_debug("grdrm: %s: cannot retrieve crtc %u: %m", card->base.name, crtc->object.id);
 922                 }
 923
 924                 return r;
 925         }
 926
 927         crtc->kern.used_fb = res.fb_id;
 928         crtc->kern.fb_offset_x = res.x;
 929         crtc->kern.fb_offset_y = res.y;
 930         crtc->kern.gamma_size = res.gamma_size;
 931         crtc->kern.mode_set = res.mode_valid;
 932         crtc->kern.mode = res.mode;
 933
 934         return 0;
 935 }
 936
 937 static void grdrm_crtc_assign(grdrm_crtc *crtc, grdrm_connector *connector) {
 938         uint32_t n_connectors;
 939         int r;
 940
 941         assert(crtc);
 942         assert(!crtc->object.assigned);
 943         assert(!connector || !connector->object.assigned);
 944
 945         /* always mark both as assigned; even if assignments cannot be set */
 946         crtc->object.assigned = true;
 947         if (connector)
 948                 connector->object.assigned = true;
 949
 950         /* we will support hw clone mode in the future */
 951         n_connectors = connector ? 1 : 0;
 952
 953         /* bail out if configuration is preserved */
 954         if (crtc->set.n_connectors == n_connectors &&
 955             (n_connectors == 0 || crtc->set.connectors[0] == connector->object.id))
 956                 return;
 957
 958         crtc->applied = false;
 959         crtc->set.n_connectors = 0;
 960
 961         if (n_connectors > crtc->set.max_connectors) {
 962                 uint32_t max, *t;
 963
 964                 max = ALIGN_POWER2(n_connectors);
 965                 if (!max) {
 966                         r = -ENOMEM;
 967                         goto error;
 968                 }
 969
 970                 t = realloc(crtc->set.connectors, sizeof(*t) * max);
 971                 if (!t) {
 972                         r = -ENOMEM;
 973                         goto error;
 974                 }
 975
 976                 crtc->set.connectors = t;
 977                 crtc->set.max_connectors = max;
 978         }
 979
 980         if (connector) {
 981                 struct drm_mode_modeinfo *m, *pref = NULL;
 982                 uint32_t i;
 983
 984                 for (i = 0; i < connector->kern.n_modes; ++i) {
 985                         m = &connector->kern.modes[i];
 986
 987                         /* ignore 3D modes by default */
 988                         if (m->flags & DRM_MODE_FLAG_3D_MASK)
 989                                 continue;
 990
 991                         if (!pref) {
 992                                 pref = m;
 993                                 continue;
 994                         }
 995
 996                         /* use PREFERRED over non-PREFERRED */
 997                         if ((pref->type & DRM_MODE_TYPE_PREFERRED) &&
 998                             !(m->type & DRM_MODE_TYPE_PREFERRED))
 999                                 continue;
1000
1001                         /* use DRIVER over non-PREFERRED|DRIVER */
1002                         if ((pref->type & DRM_MODE_TYPE_DRIVER) &&
1003                             !(m->type & (DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED)))
1004                                 continue;
1005
1006                         /* always prefer higher resolution */
1007                         if (pref->hdisplay > m->hdisplay ||
1008                             (pref->hdisplay == m->hdisplay && pref->vdisplay > m->vdisplay))
1009                                 continue;
1010
1011                         pref = m;
1012                 }
1013
1014                 if (pref) {
1015                         crtc->set.mode = *pref;
1016                         crtc->set.n_connectors = 1;
1017                         crtc->set.connectors[0] = connector->object.id;
1018                         log_debug("grdrm: %s: assigned connector %" PRIu32 " to crtc %" PRIu32 " with mode %s",
1019                                   crtc->object.card->base.name, connector->object.id, crtc->object.id, pref->name);
1020                 } else {
1021                         log_debug("grdrm: %s: connector %" PRIu32 " to be assigned but has no valid mode",
1022                                   crtc->object.card->base.name, connector->object.id);
1023                 }
1024         }
1025
1026         return;
1027
1028 error:
1029         log_debug("grdrm: %s: cannot assign crtc %" PRIu32 ": %s",
1030                   crtc->object.card->base.name, crtc->object.id, strerror(-r));
1031 }
1032
1033 static void grdrm_crtc_expose(grdrm_crtc *crtc) {
1034         grdrm_pipe *pipe;
1035         grdrm_fb *fb;
1036         size_t i;
1037         int r;
1038
1039         assert(crtc);
1040         assert(crtc->object.assigned);
1041
1042         if (crtc->set.n_connectors < 1) {
1043                 if (crtc->pipe)
1044                         grdev_pipe_free(&crtc->pipe->base);
1045                 crtc->pipe = NULL;
1046                 return;
1047         }
1048
1049         pipe = crtc->pipe;
1050         if (pipe) {
1051                 if (pipe->base.width != crtc->set.mode.hdisplay ||
1052                     pipe->base.height != crtc->set.mode.vdisplay ||
1053                     pipe->base.vrefresh != crtc->set.mode.vrefresh) {
1054                         grdev_pipe_free(&pipe->base);
1055                         crtc->pipe = NULL;
1056                         pipe = NULL;
1057                 }
1058         }
1059
1060         if (crtc->pipe) {
1061                 pipe->base.front = NULL;
1062                 pipe->base.back = NULL;
1063                 for (i = 0; i < pipe->base.max_fbs; ++i) {
1064                         fb = fb_from_base(pipe->base.fbs[i]);
1065                         if (fb->id == crtc->kern.used_fb)
1066                                 pipe->base.front = &fb->base;
1067                         else if (!fb->flipid)
1068                                 pipe->base.back = &fb->base;
1069                 }
1070         } else {
1071                 r = grdrm_pipe_new(&pipe, crtc, &crtc->set.mode, 2);
1072                 if (r < 0) {
1073                         log_debug("grdrm: %s: cannot create pipe for crtc %" PRIu32 ": %s",
1074                                   crtc->object.card->base.name, crtc->object.id, strerror(-r));
1075                         return;
1076                 }
1077
1078                 for (i = 0; i < pipe->base.max_fbs; ++i) {
1079                         r = grdrm_fb_new(&fb, crtc->object.card, &crtc->set.mode);
1080                         if (r < 0) {
1081                                 log_debug("grdrm: %s: cannot allocate framebuffer for crtc %" PRIu32 ": %s",
1082                                           crtc->object.card->base.name, crtc->object.id, strerror(-r));
1083                                 grdev_pipe_free(&pipe->base);
1084                                 return;
1085                         }
1086
1087                         pipe->base.fbs[i] = &fb->base;
1088                 }
1089
1090                 pipe->base.front = NULL;
1091                 pipe->base.back = pipe->base.fbs[0];
1092                 crtc->pipe = pipe;
1093         }
1094
1095         grdev_pipe_ready(&crtc->pipe->base, true);
1096 }
1097
1098 static void grdrm_crtc_commit_deep(grdrm_crtc *crtc, grdev_fb *basefb) {
1099         struct drm_mode_crtc set_crtc = { .crtc_id = crtc->object.id };
1100         grdrm_card *card = crtc->object.card;
1101         grdrm_pipe *pipe = crtc->pipe;
1102         grdrm_fb *fb;
1103         int r;
1104
1105         assert(crtc);
1106         assert(basefb);
1107         assert(pipe);
1108
1109         fb = fb_from_base(basefb);
1110
1111         set_crtc.set_connectors_ptr = PTR_TO_UINT64(crtc->set.connectors);
1112         set_crtc.count_connectors = crtc->set.n_connectors;
1113         set_crtc.fb_id = fb->id;
1114         set_crtc.x = 0;
1115         set_crtc.y = 0;
1116         set_crtc.mode_valid = 1;
1117         set_crtc.mode = crtc->set.mode;
1118
1119         r = ioctl(card->fd, DRM_IOCTL_MODE_SETCRTC, &set_crtc);
1120         if (r < 0) {
1121                 r = -errno;
1122                 log_debug("grdrm: %s: cannot set crtc %" PRIu32 ": %m",
1123                           card->base.name, crtc->object.id);
1124
1125                 grdrm_card_async(card, r);
1126                 return;
1127         }
1128
1129         if (!crtc->applied) {
1130                 log_debug("grdrm: %s: crtc %" PRIu32 " applied via deep modeset",
1131                           card->base.name, crtc->object.id);
1132                 crtc->applied = true;
1133         }
1134
1135         pipe->base.back = NULL;
1136         pipe->base.front = &fb->base;
1137         fb->flipid = 0;
1138         ++pipe->counter;
1139         pipe->base.flipping = false;
1140         pipe->base.flip = false;
1141
1142         /* We cannot schedule dummy page-flips on pipes, hence, the
1143          * application would have to schedule their own frame-timers.
1144          * To avoid duplicating that everywhere, we schedule our own
1145          * timer and raise a fake FRAME event when it fires. */
1146         grdev_pipe_schedule(&pipe->base, 1);
1147 }
1148
1149 static int grdrm_crtc_commit_flip(grdrm_crtc *crtc, grdev_fb *basefb) {
1150         struct drm_mode_crtc_page_flip page_flip = { .crtc_id = crtc->object.id };
1151         grdrm_card *card = crtc->object.card;
1152         grdrm_pipe *pipe = crtc->pipe;
1153         grdrm_fb *fb;
1154         uint32_t cnt;
1155         int r;
1156
1157         assert(crtc);
1158         assert(basefb);
1159         assert(pipe);
1160
1161         if (!crtc->applied && !grdrm_modes_compatible(&crtc->kern.mode, &crtc->set.mode))
1162                 return 0;
1163
1164         fb = fb_from_base(basefb);
1165
1166         cnt = ++pipe->counter ? : ++pipe->counter;
1167         page_flip.fb_id = fb->id;
1168         page_flip.flags = DRM_MODE_PAGE_FLIP_EVENT;
1169         page_flip.user_data = grdrm_encode_vblank_data(crtc->object.id, cnt);
1170
1171         r = ioctl(card->fd, DRM_IOCTL_MODE_PAGE_FLIP, &page_flip);
1172         if (r < 0) {
1173                 r = -errno;
1174                 /* Avoid excessive logging on EINVAL; it is currently not
1175                  * possible to see whether cards support page-flipping, so
1176                  * avoid logging on each frame. */
1177                 if (r != -EINVAL)
1178                         log_debug("grdrm: %s: cannot schedule page-flip on crtc %" PRIu32 ": %m",
1179                                   card->base.name, crtc->object.id);
1180
1181                 if (grdrm_card_async(card, r))
1182                         return r;
1183
1184                 return 0;
1185         }
1186
1187         if (!crtc->applied) {
1188                 log_debug("grdrm: %s: crtc %" PRIu32 " applied via page flip",
1189                           card->base.name, crtc->object.id);
1190                 crtc->applied = true;
1191         }
1192
1193         pipe->base.flipping = true;
1194         pipe->base.flip = false;
1195         pipe->counter = cnt;
1196         fb->flipid = cnt;
1197         pipe->base.back = NULL;
1198
1199         /* Raise fake FRAME event if it takes longer than 2
1200          * frames to receive the pageflip event. We assume the
1201          * queue ran over or some other error happened. */
1202         grdev_pipe_schedule(&pipe->base, 2);
1203
1204         return 1;
1205 }
1206
1207 static void grdrm_crtc_commit(grdrm_crtc *crtc) {
1208         struct drm_mode_crtc set_crtc = { .crtc_id = crtc->object.id };
1209         grdrm_card *card = crtc->object.card;
1210         grdrm_pipe *pipe;
1211         grdev_fb *fb;
1212         int r;
1213
1214         assert(crtc);
1215         assert(crtc->object.assigned);
1216
1217         pipe = crtc->pipe;
1218         if (!pipe) {
1219                 /* If a crtc is not assigned any connector, we want any
1220                  * previous setup to be cleared, so make sure the CRTC is
1221                  * disabled. Otherwise, there might be content on the CRTC
1222                  * while we run, which is not what we want.
1223                  * If you want to avoid modesets on specific CRTCs, you should
1224                  * still keep their assignment, but never enable the resulting
1225                  * pipe. This way, we wouldn't touch it at all. */
1226                 if (!crtc->applied) {
1227                         crtc->applied = true;
1228                         r = ioctl(card->fd, DRM_IOCTL_MODE_SETCRTC, &set_crtc);
1229                         if (r < 0) {
1230                                 r = -errno;
1231                                 log_debug("grdrm: %s: cannot shutdown crtc %" PRIu32 ": %m",
1232                                           card->base.name, crtc->object.id);
1233
1234                                 grdrm_card_async(card, r);
1235                                 return;
1236                         }
1237
1238                         log_debug("grdrm: %s: crtc %" PRIu32 " applied via shutdown",
1239                                   card->base.name, crtc->object.id);
1240                 }
1241
1242                 return;
1243         }
1244
1245         /* we always fully ignore disabled pipes */
1246         if (!pipe->base.enabled)
1247                 return;
1248
1249         assert(crtc->set.n_connectors > 0);
1250
1251         if (pipe->base.flip)
1252                 fb = pipe->base.back;
1253         else if (!crtc->applied)
1254                 fb = pipe->base.front;
1255         else
1256                 return;
1257
1258         if (!fb)
1259                 return;
1260
1261         r = grdrm_crtc_commit_flip(crtc, fb);
1262         if (r == 0) {
1263                 /* in case we couldn't page-flip, perform deep modeset */
1264                 grdrm_crtc_commit_deep(crtc, fb);
1265         }
1266 }
1267
1268 static void grdrm_crtc_restore(grdrm_crtc *crtc) {
1269         struct drm_mode_crtc set_crtc = { .crtc_id = crtc->object.id };
1270         grdrm_card *card = crtc->object.card;
1271         int r;
1272
1273         if (!crtc->old.set)
1274                 return;
1275
1276         set_crtc.set_connectors_ptr = PTR_TO_UINT64(crtc->old.connectors);
1277         set_crtc.count_connectors = crtc->old.n_connectors;
1278         set_crtc.fb_id = crtc->old.fb;
1279         set_crtc.x = crtc->old.fb_x;
1280         set_crtc.y = crtc->old.fb_y;
1281         set_crtc.gamma_size = crtc->old.gamma;
1282         set_crtc.mode_valid = crtc->old.mode_set;
1283         set_crtc.mode = crtc->old.mode;
1284
1285         r = ioctl(card->fd, DRM_IOCTL_MODE_SETCRTC, &set_crtc);
1286         if (r < 0) {
1287                 r = -errno;
1288                 log_debug("grdrm: %s: cannot restore crtc %" PRIu32 ": %m",
1289                           card->base.name, crtc->object.id);
1290
1291                 grdrm_card_async(card, r);
1292                 return;
1293         }
1294
1295         if (crtc->pipe) {
1296                 ++crtc->pipe->counter;
1297                 crtc->pipe->base.front = NULL;
1298                 crtc->pipe->base.flipping = false;
1299         }
1300
1301         log_debug("grdrm: %s: crtc %" PRIu32 " restored", card->base.name, crtc->object.id);
1302 }
1303
1304 static void grdrm_crtc_flip_complete(grdrm_crtc *crtc, uint32_t counter, struct drm_event_vblank *event) {
1305         bool flipped = false;
1306         grdrm_pipe *pipe;
1307         size_t i;
1308
1309         assert(crtc);
1310         assert(event);
1311
1312         pipe = crtc->pipe;
1313         if (!pipe)
1314                 return;
1315
1316         /* We got a page-flip event. To be safe, we reset all FBs on the same
1317          * pipe that have smaller flipids than the flip we got as we know they
1318          * are executed in order. We need to do this to guarantee
1319          * queue-overflows or other missed events don't cause starvation.
1320          * Furthermore, if we find the exact FB this event is for, *and* this
1321          * is the most recent event, we mark it as front FB and raise a
1322          * frame event. */
1323
1324         for (i = 0; i < pipe->base.max_fbs; ++i) {
1325                 grdrm_fb *fb;
1326
1327                 if (!pipe->base.fbs[i])
1328                         continue;
1329
1330                 fb = fb_from_base(pipe->base.fbs[i]);
1331                 if (counter != 0 && counter == pipe->counter && fb->flipid == counter) {
1332                         pipe->base.front = &fb->base;
1333                         fb->flipid = 0;
1334                         flipped = true;
1335                 } else if (counter - fb->flipid < UINT16_MAX) {
1336                         fb->flipid = 0;
1337                 }
1338         }
1339
1340         if (flipped) {
1341                 crtc->pipe->base.flipping = false;
1342                 grdev_pipe_frame(&pipe->base);
1343         }
1344 }
1345
1346 /*
1347  * Framebuffers
1348  */
1349
1350 static int grdrm_fb_new(grdrm_fb **out, grdrm_card *card, const struct drm_mode_modeinfo *mode) {
1351         _cleanup_(grdrm_fb_freep) grdrm_fb *fb = NULL;
1352         struct drm_mode_create_dumb create_dumb = { };
1353         struct drm_mode_map_dumb map_dumb = { };
1354         struct drm_mode_fb_cmd2 add_fb = { };
1355         unsigned int i;
1356         int r;
1357
1358         assert_return(out, -EINVAL);
1359         assert_return(card, -EINVAL);
1360
1361         fb = new0(grdrm_fb, 1);
1362         if (!fb)
1363                 return -ENOMEM;
1364
1365         /* TODO: we should choose a compatible format of the previous CRTC
1366          * setting to allow page-flip to it. Only choose fallback if the
1367          * previous setting was crap (non xrgb32'ish). */
1368
1369         fb->card = card;
1370         fb->base.format = DRM_FORMAT_XRGB8888;
1371         fb->base.width = mode->hdisplay;
1372         fb->base.height = mode->vdisplay;
1373
1374         for (i = 0; i < ELEMENTSOF(fb->base.maps); ++i)
1375                 fb->base.maps[i] = MAP_FAILED;
1376
1377         create_dumb.width = fb->base.width;
1378         create_dumb.height = fb->base.height;
1379         create_dumb.bpp = 32;
1380
1381         r = ioctl(card->fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_dumb);
1382         if (r < 0) {
1383                 r = -errno;
1384                 log_debug("grdrm: %s: cannot create dumb buffer %" PRIu32 "x%" PRIu32": %m",
1385                           card->base.name, fb->base.width, fb->base.height);
1386                 return r;
1387         }
1388
1389         fb->handles[0] = create_dumb.handle;
1390         fb->base.strides[0] = create_dumb.pitch;
1391         fb->sizes[0] = create_dumb.size;
1392
1393         map_dumb.handle = fb->handles[0];
1394
1395         r = ioctl(card->fd, DRM_IOCTL_MODE_MAP_DUMB, &map_dumb);
1396         if (r < 0) {
1397                 r = -errno;
1398                 log_debug("grdrm: %s: cannot map dumb buffer %" PRIu32 "x%" PRIu32": %m",
1399                           card->base.name, fb->base.width, fb->base.height);
1400                 return r;
1401         }
1402
1403         fb->base.maps[0] = mmap(0, fb->sizes[0], PROT_WRITE, MAP_SHARED, card->fd, map_dumb.offset);
1404         if (fb->base.maps[0] == MAP_FAILED) {
1405                 r = -errno;
1406                 log_debug("grdrm: %s: cannot memory-map dumb buffer %" PRIu32 "x%" PRIu32": %m",
1407                           card->base.name, fb->base.width, fb->base.height);
1408                 return r;
1409         }
1410
1411         memzero(fb->base.maps[0], fb->sizes[0]);
1412
1413         add_fb.width = fb->base.width;
1414         add_fb.height = fb->base.height;
1415         add_fb.pixel_format = fb->base.format;
1416         add_fb.flags = 0;
1417         memcpy(add_fb.handles, fb->handles, sizeof(fb->handles));
1418         memcpy(add_fb.pitches, fb->base.strides, sizeof(fb->base.strides));
1419         memcpy(add_fb.offsets, fb->offsets, sizeof(fb->offsets));
1420
1421         r = ioctl(card->fd, DRM_IOCTL_MODE_ADDFB2, &add_fb);
1422         if (r < 0) {
1423                 r = -errno;
1424                 log_debug("grdrm: %s: cannot add framebuffer %" PRIu32 "x%" PRIu32": %m",
1425                           card->base.name, fb->base.width, fb->base.height);
1426                 return r;
1427         }
1428
1429         fb->id = add_fb.fb_id;
1430
1431         *out = fb;
1432         fb = NULL;
1433         return 0;
1434 }
1435
1436 grdrm_fb *grdrm_fb_free(grdrm_fb *fb) {
1437         unsigned int i;
1438         int r;
1439
1440         if (!fb)
1441                 return NULL;
1442
1443         assert(fb->card);
1444
1445         if (fb->id > 0 && fb->card->fd >= 0) {
1446                 r = ioctl(fb->card->fd, DRM_IOCTL_MODE_RMFB, fb->id);
1447                 if (r < 0)
1448                         log_debug("grdrm: %s: cannot delete framebuffer %" PRIu32 ": %m",
1449                                   fb->card->base.name, fb->id);
1450         }
1451
1452         for (i = 0; i < ELEMENTSOF(fb->handles); ++i) {
1453                 struct drm_mode_destroy_dumb destroy_dumb = { };
1454
1455                 if (fb->base.maps[i] != MAP_FAILED)
1456                         munmap(fb->base.maps[i], fb->sizes[i]);
1457
1458                 if (fb->handles[i] > 0 && fb->card->fd >= 0) {
1459                         destroy_dumb.handle = fb->handles[i];
1460                         r = ioctl(fb->card->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_dumb);
1461                         if (r < 0)
1462                                 log_debug("grdrm: %s: cannot destroy dumb-buffer %" PRIu32 ": %m",
1463                                           fb->card->base.name, fb->handles[i]);
1464                 }
1465         }
1466
1467         free(fb);
1468
1469         return NULL;
1470 }
1471
1472 /*
1473  * Pipes
1474  */
1475
1476 static void grdrm_pipe_name(char *out, grdrm_crtc *crtc) {
1477         /* @out must be at least of size GRDRM_PIPE_NAME_MAX */
1478         sprintf(out, "%s/%" PRIu32, crtc->object.card->base.name, crtc->object.id);
1479 }
1480
1481 static int grdrm_pipe_new(grdrm_pipe **out, grdrm_crtc *crtc, struct drm_mode_modeinfo *mode, size_t n_fbs) {
1482         _cleanup_(grdev_pipe_freep) grdev_pipe *basepipe = NULL;
1483         grdrm_card *card = crtc->object.card;
1484         char name[GRDRM_PIPE_NAME_MAX];
1485         grdrm_pipe *pipe;
1486         int r;
1487
1488         assert_return(crtc, -EINVAL);
1489         assert_return(grdev_is_drm_card(&card->base), -EINVAL);
1490
1491         pipe = new0(grdrm_pipe, 1);
1492         if (!pipe)
1493                 return -ENOMEM;
1494
1495         basepipe = &pipe->base;
1496         pipe->base = GRDEV_PIPE_INIT(&grdrm_pipe_vtable, &card->base);
1497         pipe->crtc = crtc;
1498         pipe->base.width = mode->hdisplay;
1499         pipe->base.height = mode->vdisplay;
1500         pipe->base.vrefresh = mode->vrefresh ? : 25;
1501
1502         grdrm_pipe_name(name, crtc);
1503         r = grdev_pipe_add(&pipe->base, name, n_fbs);
1504         if (r < 0)
1505                 return r;
1506
1507         if (out)
1508                 *out = pipe;
1509         basepipe = NULL;
1510         return 0;
1511 }
1512
1513 static void grdrm_pipe_free(grdev_pipe *basepipe) {
1514         grdrm_pipe *pipe = grdrm_pipe_from_base(basepipe);
1515         size_t i;
1516
1517         assert(pipe->crtc);
1518
1519         for (i = 0; i < pipe->base.max_fbs; ++i)
1520                 if (pipe->base.fbs[i])
1521                         grdrm_fb_free(fb_from_base(pipe->base.fbs[i]));
1522
1523         free(pipe);
1524 }
1525
1526 static grdev_fb *grdrm_pipe_target(grdev_pipe *basepipe) {
1527         grdrm_fb *fb;
1528         size_t i;
1529
1530         if (!basepipe->back) {
1531                 for (i = 0; i < basepipe->max_fbs; ++i) {
1532                         if (!basepipe->fbs[i])
1533                                 continue;
1534
1535                         fb = fb_from_base(basepipe->fbs[i]);
1536                         if (&fb->base == basepipe->front)
1537                                 continue;
1538                         if (basepipe->flipping && fb->flipid)
1539                                 continue;
1540
1541                         basepipe->back = &fb->base;
1542                         break;
1543                 }
1544         }
1545
1546         return basepipe->back;
1547 }
1548
1549 static const grdev_pipe_vtable grdrm_pipe_vtable = {
1550         .free                   = grdrm_pipe_free,
1551         .target                 = grdrm_pipe_target,
1552 };
1553
1554 /*
1555  * Cards
1556  */
1557
1558 static void grdrm_name(char *out, dev_t devnum) {
1559         /* @out must be at least of size GRDRM_CARD_NAME_MAX */
1560         sprintf(out, "drm/%u:%u", major(devnum), minor(devnum));
1561 }
1562
1563 static void grdrm_card_print(grdrm_card *card) {
1564         grdrm_object *object;
1565         grdrm_crtc *crtc;
1566         grdrm_encoder *encoder;
1567         grdrm_connector *connector;
1568         grdrm_plane *plane;
1569         Iterator iter;
1570         uint32_t i;
1571         char *p, *buf;
1572
1573         log_debug("grdrm: %s: state dump", card->base.name);
1574
1575         log_debug("  crtcs:");
1576         HASHMAP_FOREACH(object, card->object_map, iter) {
1577                 if (object->type != GRDRM_TYPE_CRTC)
1578                         continue;
1579
1580                 crtc = crtc_from_object(object);
1581                 log_debug("    (id: %u index: %d)", object->id, object->index);
1582
1583                 if (crtc->kern.mode_set)
1584                         log_debug("      mode: %dx%d", crtc->kern.mode.hdisplay, crtc->kern.mode.vdisplay);
1585                 else
1586                         log_debug("      mode: <none>");
1587         }
1588
1589         log_debug("  encoders:");
1590         HASHMAP_FOREACH(object, card->object_map, iter) {
1591                 if (object->type != GRDRM_TYPE_ENCODER)
1592                         continue;
1593
1594                 encoder = encoder_from_object(object);
1595                 log_debug("    (id: %u index: %d)", object->id, object->index);
1596
1597                 if (encoder->kern.used_crtc)
1598                         log_debug("      crtc: %u", encoder->kern.used_crtc);
1599                 else
1600                         log_debug("      crtc: <none>");
1601
1602                 buf = malloc((DECIMAL_STR_MAX(uint32_t) + 1) * encoder->kern.n_crtcs + 1);
1603                 if (buf) {
1604                         buf[0] = 0;
1605                         p = buf;
1606
1607                         for (i = 0; i < encoder->kern.n_crtcs; ++i)
1608                                 p += sprintf(p, " %" PRIu32, encoder->kern.crtcs[i]);
1609
1610                         log_debug("      possible crtcs:%s", buf);
1611                         free(buf);
1612                 }
1613
1614                 buf = malloc((DECIMAL_STR_MAX(uint32_t) + 1) * encoder->kern.n_clones + 1);
1615                 if (buf) {
1616                         buf[0] = 0;
1617                         p = buf;
1618
1619                         for (i = 0; i < encoder->kern.n_clones; ++i)
1620                                 p += sprintf(p, " %" PRIu32, encoder->kern.clones[i]);
1621
1622                         log_debug("      possible clones:%s", buf);
1623                         free(buf);
1624                 }
1625         }
1626
1627         log_debug("  connectors:");
1628         HASHMAP_FOREACH(object, card->object_map, iter) {
1629                 if (object->type != GRDRM_TYPE_CONNECTOR)
1630                         continue;
1631
1632                 connector = connector_from_object(object);
1633                 log_debug("    (id: %u index: %d)", object->id, object->index);
1634                 log_debug("      type: %" PRIu32 "-%" PRIu32 " connection: %" PRIu32 " subpixel: %" PRIu32 " extents: %" PRIu32 "x%" PRIu32,
1635                           connector->kern.type, connector->kern.type_id, connector->kern.connection, connector->kern.subpixel,
1636                           connector->kern.mm_width, connector->kern.mm_height);
1637
1638                 if (connector->kern.used_encoder)
1639                         log_debug("      encoder: %" PRIu32, connector->kern.used_encoder);
1640                 else
1641                         log_debug("      encoder: <none>");
1642
1643                 buf = malloc((DECIMAL_STR_MAX(uint32_t) + 1) * connector->kern.n_encoders + 1);
1644                 if (buf) {
1645                         buf[0] = 0;
1646                         p = buf;
1647
1648                         for (i = 0; i < connector->kern.n_encoders; ++i)
1649                                 p += sprintf(p, " %" PRIu32, connector->kern.encoders[i]);
1650
1651                         log_debug("      possible encoders:%s", buf);
1652                         free(buf);
1653                 }
1654
1655                 for (i = 0; i < connector->kern.n_modes; ++i) {
1656                         struct drm_mode_modeinfo *mode = &connector->kern.modes[i];
1657                         log_debug("      mode: %" PRIu32 "x%" PRIu32, mode->hdisplay, mode->vdisplay);
1658                 }
1659         }
1660
1661         log_debug("  planes:");
1662         HASHMAP_FOREACH(object, card->object_map, iter) {
1663                 if (object->type != GRDRM_TYPE_PLANE)
1664                         continue;
1665
1666                 plane = plane_from_object(object);
1667                 log_debug("    (id: %u index: %d)", object->id, object->index);
1668                 log_debug("      gamma-size: %" PRIu32, plane->kern.gamma_size);
1669
1670                 if (plane->kern.used_crtc)
1671                         log_debug("      crtc: %" PRIu32, plane->kern.used_crtc);
1672                 else
1673                         log_debug("      crtc: <none>");
1674
1675                 buf = malloc((DECIMAL_STR_MAX(uint32_t) + 1) * plane->kern.n_crtcs + 1);
1676                 if (buf) {
1677                         buf[0] = 0;
1678                         p = buf;
1679
1680                         for (i = 0; i < plane->kern.n_crtcs; ++i)
1681                                 p += sprintf(p, " %" PRIu32, plane->kern.crtcs[i]);
1682
1683                         log_debug("      possible crtcs:%s", buf);
1684                         free(buf);
1685                 }
1686
1687                 buf = malloc((DECIMAL_STR_MAX(unsigned int) + 3) * plane->kern.n_formats + 1);
1688                 if (buf) {
1689                         buf[0] = 0;
1690                         p = buf;
1691
1692                         for (i = 0; i < plane->kern.n_formats; ++i)
1693                                 p += sprintf(p, " 0x%x", (unsigned int)plane->kern.formats[i]);
1694
1695                         log_debug("      possible formats:%s", buf);
1696                         free(buf);
1697                 }
1698         }
1699 }
1700
1701 static int grdrm_card_resync(grdrm_card *card) {
1702         _cleanup_free_ uint32_t *crtc_ids = NULL, *encoder_ids = NULL, *connector_ids = NULL, *plane_ids = NULL;
1703         uint32_t allocated = 0;
1704         grdrm_object *object;
1705         Iterator iter;
1706         size_t tries;
1707         int r;
1708
1709         assert(card);
1710
1711         card->async_hotplug = false;
1712         allocated = 0;
1713
1714         /* mark existing objects for possible removal */
1715         HASHMAP_FOREACH(object, card->object_map, iter)
1716                 object->present = false;
1717
1718         for (tries = 0; tries < GRDRM_MAX_TRIES; ++tries) {
1719                 struct drm_mode_get_plane_res pres;
1720                 struct drm_mode_card_res res;
1721                 uint32_t i, max;
1722
1723                 if (allocated < card->max_ids) {
1724                         free(crtc_ids);
1725                         free(encoder_ids);
1726                         free(connector_ids);
1727                         free(plane_ids);
1728                         crtc_ids = new0(uint32_t, card->max_ids);
1729                         encoder_ids = new0(uint32_t, card->max_ids);
1730                         connector_ids = new0(uint32_t, card->max_ids);
1731                         plane_ids = new0(uint32_t, card->max_ids);
1732
1733                         if (!crtc_ids || !encoder_ids || !connector_ids || !plane_ids)
1734                                 return -ENOMEM;
1735
1736                         allocated = card->max_ids;
1737                 }
1738
1739                 zero(res);
1740                 res.crtc_id_ptr = PTR_TO_UINT64(crtc_ids);
1741                 res.connector_id_ptr = PTR_TO_UINT64(connector_ids);
1742                 res.encoder_id_ptr = PTR_TO_UINT64(encoder_ids);
1743                 res.count_crtcs = allocated;
1744                 res.count_encoders = allocated;
1745                 res.count_connectors = allocated;
1746
1747                 r = ioctl(card->fd, DRM_IOCTL_MODE_GETRESOURCES, &res);
1748                 if (r < 0) {
1749                         r = -errno;
1750                         log_debug("grdrm: %s: cannot retrieve drm resources: %m", card->base.name);
1751                         return r;
1752                 }
1753
1754                 zero(pres);
1755                 pres.plane_id_ptr = PTR_TO_UINT64(plane_ids);
1756                 pres.count_planes = allocated;
1757
1758                 r = ioctl(card->fd, DRM_IOCTL_MODE_GETPLANERESOURCES, &pres);
1759                 if (r < 0) {
1760                         r = -errno;
1761                         log_debug("grdrm: %s: cannot retrieve drm plane-resources: %m", card->base.name);
1762                         return r;
1763                 }
1764
1765                 max = MAX(MAX(res.count_crtcs, res.count_encoders),
1766                           MAX(res.count_connectors, pres.count_planes));
1767                 if (max > allocated) {
1768                         uint32_t n;
1769
1770                         n = ALIGN_POWER2(max);
1771                         if (!n || n > UINT16_MAX) {
1772                                 log_debug("grdrm: %s: excessive DRM resource limit: %" PRIu32, card->base.name, max);
1773                                 return -ERANGE;
1774                         }
1775
1776                         /* retry with resized buffers */
1777                         card->max_ids = n;
1778                         continue;
1779                 }
1780
1781                 /* mark available objects as present */
1782
1783                 for (i = 0; i < res.count_crtcs; ++i) {
1784                         object = grdrm_find_object(card, crtc_ids[i]);
1785                         if (object && object->type == GRDRM_TYPE_CRTC) {
1786                                 object->present = true;
1787                                 object->index = i;
1788                                 crtc_ids[i] = 0;
1789                         }
1790                 }
1791
1792                 for (i = 0; i < res.count_encoders; ++i) {
1793                         object = grdrm_find_object(card, encoder_ids[i]);
1794                         if (object && object->type == GRDRM_TYPE_ENCODER) {
1795                                 object->present = true;
1796                                 object->index = i;
1797                                 encoder_ids[i] = 0;
1798                         }
1799                 }
1800
1801                 for (i = 0; i < res.count_connectors; ++i) {
1802                         object = grdrm_find_object(card, connector_ids[i]);
1803                         if (object && object->type == GRDRM_TYPE_CONNECTOR) {
1804                                 object->present = true;
1805                                 object->index = i;
1806                                 connector_ids[i] = 0;
1807                         }
1808                 }
1809
1810                 for (i = 0; i < pres.count_planes; ++i) {
1811                         object = grdrm_find_object(card, plane_ids[i]);
1812                         if (object && object->type == GRDRM_TYPE_PLANE) {
1813                                 object->present = true;
1814                                 object->index = i;
1815                                 plane_ids[i] = 0;
1816                         }
1817                 }
1818
1819                 /* drop removed objects */
1820
1821                 HASHMAP_FOREACH(object, card->object_map, iter)
1822                         if (!object->present)
1823                                 grdrm_object_free(object);
1824
1825                 /* add new objects */
1826
1827                 card->n_crtcs = res.count_crtcs;
1828                 for (i = 0; i < res.count_crtcs; ++i) {
1829                         if (crtc_ids[i] < 1)
1830                                 continue;
1831
1832                         r = grdrm_crtc_new(NULL, card, crtc_ids[i], i);
1833                         if (r < 0)
1834                                 return r;
1835                 }
1836
1837                 card->n_encoders = res.count_encoders;
1838                 for (i = 0; i < res.count_encoders; ++i) {
1839                         if (encoder_ids[i] < 1)
1840                                 continue;
1841
1842                         r = grdrm_encoder_new(NULL, card, encoder_ids[i], i);
1843                         if (r < 0)
1844                                 return r;
1845                 }
1846
1847                 card->n_connectors = res.count_connectors;
1848                 for (i = 0; i < res.count_connectors; ++i) {
1849                         if (connector_ids[i] < 1)
1850                                 continue;
1851
1852                         r = grdrm_connector_new(NULL, card, connector_ids[i], i);
1853                         if (r < 0)
1854                                 return r;
1855                 }
1856
1857                 card->n_planes = pres.count_planes;
1858                 for (i = 0; i < pres.count_planes; ++i) {
1859                         if (plane_ids[i] < 1)
1860                                 continue;
1861
1862                         r = grdrm_plane_new(NULL, card, plane_ids[i], i);
1863                         if (r < 0)
1864                                 return r;
1865                 }
1866
1867                 /* re-sync objects after object_map is synced */
1868
1869                 HASHMAP_FOREACH(object, card->object_map, iter) {
1870                         switch (object->type) {
1871                         case GRDRM_TYPE_CRTC:
1872                                 r = grdrm_crtc_resync(crtc_from_object(object));
1873                                 break;
1874                         case GRDRM_TYPE_ENCODER:
1875                                 r = grdrm_encoder_resync(encoder_from_object(object));
1876                                 break;
1877                         case GRDRM_TYPE_CONNECTOR:
1878                                 r = grdrm_connector_resync(connector_from_object(object));
1879                                 break;
1880                         case GRDRM_TYPE_PLANE:
1881                                 r = grdrm_plane_resync(plane_from_object(object));
1882                                 break;
1883                         default:
1884                                 assert_not_reached("grdrm: invalid object type");
1885                                 r = 0;
1886                         }
1887
1888                         if (r < 0)
1889                                 return r;
1890
1891                         if (card->async_hotplug)
1892                                 break;
1893                 }
1894
1895                 /* if modeset objects change during sync, start over */
1896                 if (card->async_hotplug) {
1897                         card->async_hotplug = false;
1898                         continue;
1899                 }
1900
1901                 /* cache crtc/connector relationship */
1902                 HASHMAP_FOREACH(object, card->object_map, iter) {
1903                         grdrm_connector *connector;
1904                         grdrm_encoder *encoder;
1905                         grdrm_crtc *crtc;
1906
1907                         if (object->type != GRDRM_TYPE_CONNECTOR)
1908                                 continue;
1909
1910                         connector = connector_from_object(object);
1911                         if (connector->kern.connection != 1 || connector->kern.used_encoder < 1)
1912                                 continue;
1913
1914                         object = grdrm_find_object(card, connector->kern.used_encoder);
1915                         if (!object || object->type != GRDRM_TYPE_ENCODER)
1916                                 continue;
1917
1918                         encoder = encoder_from_object(object);
1919                         if (encoder->kern.used_crtc < 1)
1920                                 continue;
1921
1922                         object = grdrm_find_object(card, encoder->kern.used_crtc);
1923                         if (!object || object->type != GRDRM_TYPE_CRTC)
1924                                 continue;
1925
1926                         crtc = crtc_from_object(object);
1927                         assert(crtc->kern.n_used_connectors < crtc->kern.max_used_connectors);
1928                         crtc->kern.used_connectors[crtc->kern.n_used_connectors++] = connector->object.id;
1929                 }
1930
1931                 /* cache old crtc settings for later restore */
1932                 HASHMAP_FOREACH(object, card->object_map, iter) {
1933                         grdrm_crtc *crtc;
1934
1935                         if (object->type != GRDRM_TYPE_CRTC)
1936                                 continue;
1937
1938                         crtc = crtc_from_object(object);
1939
1940                         /* Save data if it is the first time we refresh the CRTC. This data can
1941                          * be used optionally to restore any previous configuration. For
1942                          * instance, it allows us to restore VT configurations after we close
1943                          * our session again. */
1944                         if (!crtc->old.set) {
1945                                 crtc->old.fb = crtc->kern.used_fb;
1946                                 crtc->old.fb_x = crtc->kern.fb_offset_x;
1947                                 crtc->old.fb_y = crtc->kern.fb_offset_y;
1948                                 crtc->old.gamma = crtc->kern.gamma_size;
1949                                 crtc->old.n_connectors = crtc->kern.n_used_connectors;
1950                                 if (crtc->old.n_connectors)
1951                                         memcpy(crtc->old.connectors, crtc->kern.used_connectors, sizeof(uint32_t) * crtc->old.n_connectors);
1952                                 crtc->old.mode_set = crtc->kern.mode_set;
1953                                 crtc->old.mode = crtc->kern.mode;
1954                                 crtc->old.set = true;
1955                         }
1956                 }
1957
1958                 /* everything synced */
1959                 break;
1960         }
1961
1962         if (tries >= GRDRM_MAX_TRIES) {
1963                 /*
1964                  * Ugh! We were unable to sync the DRM card state due to heavy
1965                  * hotplugging. This should never happen, so print a debug
1966                  * message and bail out. The next uevent will trigger
1967                  * this again.
1968                  */
1969
1970                 log_debug("grdrm: %s: hotplug-storm when syncing card", card->base.name);
1971                 return -EFAULT;
1972         }
1973
1974         return 0;
1975 }
1976
1977 static bool card_configure_crtc(grdrm_crtc *crtc, grdrm_connector *connector) {
1978         grdrm_card *card = crtc->object.card;
1979         grdrm_encoder *encoder;
1980         grdrm_object *object;
1981         uint32_t i, j;
1982
1983         if (crtc->object.assigned || connector->object.assigned)
1984                 return false;
1985         if (connector->kern.connection != 1)
1986                 return false;
1987
1988         for (i = 0; i < connector->kern.n_encoders; ++i) {
1989                 object = grdrm_find_object(card, connector->kern.encoders[i]);
1990                 if (!object || object->type != GRDRM_TYPE_ENCODER)
1991                         continue;
1992
1993                 encoder = encoder_from_object(object);
1994                 for (j = 0; j < encoder->kern.n_crtcs; ++j) {
1995                         if (encoder->kern.crtcs[j] == crtc->object.id) {
1996                                 grdrm_crtc_assign(crtc, connector);
1997                                 return true;
1998                         }
1999                 }
2000         }
2001
2002         return false;
2003 }
2004
2005 static void grdrm_card_configure(grdrm_card *card) {
2006         /*
2007          * Modeset Configuration
2008          * This is where we update our modeset configuration and assign
2009          * connectors to CRTCs. This means, each connector that we want to
2010          * enable needs a CRTC, disabled (or unavailable) connectors are left
2011          * alone in the dark. Once all CRTCs are assigned, the remaining CRTCs
2012          * are disabled.
2013          * Sounds trivial, but there're several caveats:
2014          *
2015          *   * Multiple connectors can be driven by the same CRTC. This is
2016          *     known as 'hardware clone mode'. Advantage over software clone
2017          *     mode is that only a single CRTC is needed to drive multiple
2018          *     displays. However, few hardware supports this and it's a huge
2019          *     headache to configure on dynamic demands. Therefore, we only
2020          *     support it if configured statically beforehand.
2021          *
2022          *   * CRTCs are not created equal. Some might be much more poweful
2023          *     than others, including more advanced plane support. So far, our
2024          *     CRTC selection is random. You need to supply static
2025          *     configuration if you want special setups. So far, there is no
2026          *     proper way to do advanced CRTC selection on dynamic demands. It
2027          *     is not really clear which demands require what CRTC, so, like
2028          *     everyone else, we do random CRTC selection unless explicitly
2029          *     states otherwise.
2030          *
2031          *   * Each Connector has a list of possible encoders that can drive
2032          *     it, and each encoder has a list of possible CRTCs. If this graph
2033          *     is a tree, assignment is trivial. However, if not, we cannot
2034          *     reliably decide on configurations beforehand. The encoder is
2035          *     always selected by the kernel, so we have to actually set a mode
2036          *     to know which encoder is used. There is no way to ask the kernel
2037          *     whether a given configuration is possible. This will change with
2038          *     atomic-modesetting, but until then, we keep our configurations
2039          *     simple and assume they work all just fine. If one fails
2040          *     unexpectedly, we print a warning and disable it.
2041          *
2042          * Configuring a card consists of several steps:
2043          *
2044          *  1) First of all, we apply any user-configuration. If a user wants
2045          *     a fixed configuration, we apply it and preserve it.
2046          *     So far, we don't support user configuration files, so this step
2047          *     is skipped.
2048          *
2049          *  2) Secondly, we need to apply any quirks from hwdb. Some hardware
2050          *     might only support limited configurations or require special
2051          *     CRTC/Connector mappings. We read this from hwdb and apply it, if
2052          *     present.
2053          *     So far, we don't support this as there is no known quirk, so
2054          *     this step is skipped.
2055          *
2056          *  3) As deep modesets are expensive, we try to avoid them if
2057          *     possible. Therefore, we read the current configuration from the
2058          *     kernel and try to preserve it, if compatible with our demands.
2059          *     If not, we break it and reassign it in a following step.
2060          *
2061          *  4) The main step involves configuring all remaining objects. By
2062          *     default, all available connectors are enabled, except for those
2063          *     disabled by user-configuration. We lookup a suitable CRTC for
2064          *     each connector and assign them. As there might be more
2065          *     connectors than CRTCs, we apply some ordering so users can
2066          *     select which connectors are more important right now.
2067          *     So far, we only apply the default ordering, more might be added
2068          *     in the future.
2069          */
2070
2071         grdrm_object *object;
2072         grdrm_crtc *crtc;
2073         Iterator i, j;
2074
2075         /* clear assignments */
2076         HASHMAP_FOREACH(object, card->object_map, i)
2077                 object->assigned = false;
2078
2079         /* preserve existing configurations */
2080         HASHMAP_FOREACH(object, card->object_map, i) {
2081                 if (object->type != GRDRM_TYPE_CRTC || object->assigned)
2082                         continue;
2083
2084                 crtc = crtc_from_object(object);
2085
2086                 if (crtc->applied) {
2087                         /* If our mode is set, preserve it. If no connector is
2088                          * set, modeset either failed or the pipe is unused. In
2089                          * both cases, leave it alone. It might be tried again
2090                          * below in case there're remaining connectors.
2091                          * Otherwise, try restoring the assignments. If they
2092                          * are no longer valid, leave the pipe untouched. */
2093
2094                         if (crtc->set.n_connectors < 1)
2095                                 continue;
2096
2097                         assert(crtc->set.n_connectors == 1);
2098
2099                         object = grdrm_find_object(card, crtc->set.connectors[0]);
2100                         if (!object || object->type != GRDRM_TYPE_CONNECTOR)
2101                                 continue;
2102
2103                         card_configure_crtc(crtc, connector_from_object(object));
2104                 } else if (crtc->kern.mode_set && crtc->kern.n_used_connectors != 1) {
2105                         /* If our mode is not set on the pipe, we know the kern
2106                          * information is valid. Try keeping it. If it's not
2107                          * possible, leave the pipe untouched for later
2108                          * assignements. */
2109
2110                         object = grdrm_find_object(card, crtc->kern.used_connectors[0]);
2111                         if (!object || object->type != GRDRM_TYPE_CONNECTOR)
2112                                 continue;
2113
2114                         card_configure_crtc(crtc, connector_from_object(object));
2115                 }
2116         }
2117
2118         /* assign remaining objects */
2119         HASHMAP_FOREACH(object, card->object_map, i) {
2120                 if (object->type != GRDRM_TYPE_CRTC || object->assigned)
2121                         continue;
2122
2123                 crtc = crtc_from_object(object);
2124
2125                 HASHMAP_FOREACH(object, card->object_map, j) {
2126                         if (object->type != GRDRM_TYPE_CONNECTOR)
2127                                 continue;
2128
2129                         if (card_configure_crtc(crtc, connector_from_object(object)))
2130                                 break;
2131                 }
2132
2133                 if (!crtc->object.assigned)
2134                         grdrm_crtc_assign(crtc, NULL);
2135         }
2136
2137         /* expose configuration */
2138         HASHMAP_FOREACH(object, card->object_map, i) {
2139                 if (object->type != GRDRM_TYPE_CRTC)
2140                         continue;
2141
2142                 grdrm_crtc_expose(crtc_from_object(object));
2143         }
2144 }
2145
2146 static void grdrm_card_hotplug(grdrm_card *card) {
2147         int r;
2148
2149         assert(card);
2150
2151         if (!card->running)
2152                 return;
2153
2154         log_debug("grdrm: %s/%s: reconfigure card", card->base.session->name, card->base.name);
2155
2156         card->ready = false;
2157         r = grdrm_card_resync(card);
2158         if (r < 0) {
2159                 log_debug("grdrm: %s/%s: cannot re-sync card: %s",
2160                           card->base.session->name, card->base.name, strerror(-r));
2161                 return;
2162         }
2163
2164         grdev_session_pin(card->base.session);
2165
2166         /* debug statement to print card information */
2167         if (0)
2168                 grdrm_card_print(card);
2169
2170         grdrm_card_configure(card);
2171         card->ready = true;
2172         card->hotplug = false;
2173
2174         grdev_session_unpin(card->base.session);
2175 }
2176
2177 static int grdrm_card_io_fn(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2178         grdrm_card *card = userdata;
2179         struct drm_event_vblank *vblank;
2180         struct drm_event *event;
2181         uint32_t id, counter;
2182         grdrm_object *object;
2183         char buf[4096];
2184         size_t len;
2185         ssize_t l;
2186
2187         if (revents & (EPOLLHUP | EPOLLERR)) {
2188                 /* Immediately close device on HUP; no need to flush pending
2189                  * data.. there're no events we care about here. */
2190                 log_debug("grdrm: %s/%s: HUP", card->base.session->name, card->base.name);
2191                 grdrm_card_close(card);
2192                 return 0;
2193         }
2194
2195         if (revents & (EPOLLIN)) {
2196                 l = read(card->fd, buf, sizeof(buf));
2197                 if (l < 0) {
2198                         if (errno == EAGAIN || errno == EINTR)
2199                                 return 0;
2200
2201                         log_debug("grdrm: %s/%s: read error: %m", card->base.session->name, card->base.name);
2202                         grdrm_card_close(card);
2203                         return 0;
2204                 }
2205
2206                 for (len = l; len > 0; len -= event->length) {
2207                         event = (void*)buf;
2208
2209                         if (len < sizeof(*event) || len < event->length) {
2210                                 log_debug("grdrm: %s/%s: truncated event", card->base.session->name, card->base.name);
2211                                 break;
2212                         }
2213
2214                         switch (event->type) {
2215                         case DRM_EVENT_FLIP_COMPLETE:
2216                                 vblank = (void*)event;
2217                                 if (event->length < sizeof(*vblank)) {
2218                                         log_debug("grdrm: %s/%s: truncated vblank event", card->base.session->name, card->base.name);
2219                                         break;
2220                                 }
2221
2222                                 grdrm_decode_vblank_data(vblank->user_data, &id, &counter);
2223                                 object = grdrm_find_object(card, id);
2224                                 if (!object || object->type != GRDRM_TYPE_CRTC)
2225                                         break;
2226
2227                                 grdrm_crtc_flip_complete(crtc_from_object(object), counter, vblank);
2228                                 break;
2229                         }
2230                 }
2231         }
2232
2233         return 0;
2234 }
2235
2236 static int grdrm_card_add(grdrm_card *card, const char *name) {
2237         assert(card);
2238         assert(card->fd < 0);
2239
2240         card->object_map = hashmap_new(&trivial_hash_ops);
2241         if (!card->object_map)
2242                 return -ENOMEM;
2243
2244         return grdev_card_add(&card->base, name);
2245 }
2246
2247 static void grdrm_card_destroy(grdrm_card *card) {
2248         assert(card);
2249         assert(!card->running);
2250         assert(card->fd < 0);
2251         assert(hashmap_size(card->object_map) == 0);
2252
2253         hashmap_free(card->object_map);
2254 }
2255
2256 static void grdrm_card_commit(grdev_card *basecard) {
2257         grdrm_card *card = grdrm_card_from_base(basecard);
2258         grdrm_object *object;
2259         Iterator iter;
2260
2261         HASHMAP_FOREACH(object, card->object_map, iter) {
2262                 if (!card->ready)
2263                         break;
2264
2265                 if (object->type != GRDRM_TYPE_CRTC)
2266                         continue;
2267
2268                 grdrm_crtc_commit(crtc_from_object(object));
2269         }
2270 }
2271
2272 static void grdrm_card_restore(grdev_card *basecard) {
2273         grdrm_card *card = grdrm_card_from_base(basecard);
2274         grdrm_object *object;
2275         Iterator iter;
2276
2277         HASHMAP_FOREACH(object, card->object_map, iter) {
2278                 if (!card->ready)
2279                         break;
2280
2281                 if (object->type != GRDRM_TYPE_CRTC)
2282                         continue;
2283
2284                 grdrm_crtc_restore(crtc_from_object(object));
2285         }
2286 }
2287
2288 static void grdrm_card_enable(grdrm_card *card) {
2289         assert(card);
2290
2291         if (card->fd < 0 || card->running)
2292                 return;
2293
2294         /* ignore cards without DUMB_BUFFER capability */
2295         if (!card->cap_dumb)
2296                 return;
2297
2298         assert(card->fd_src);
2299
2300         log_debug("grdrm: %s/%s: enable", card->base.session->name, card->base.name);
2301
2302         card->running = true;
2303         sd_event_source_set_enabled(card->fd_src, SD_EVENT_ON);
2304         grdrm_card_hotplug(card);
2305 }
2306
2307 static void grdrm_card_disable(grdrm_card *card) {
2308         grdrm_object *object;
2309         Iterator iter;
2310
2311         assert(card);
2312
2313         if (card->fd < 0 || !card->running)
2314                 return;
2315
2316         assert(card->fd_src);
2317
2318         log_debug("grdrm: %s/%s: disable", card->base.session->name, card->base.name);
2319
2320         card->running = false;
2321         card->ready = false;
2322         sd_event_source_set_enabled(card->fd_src, SD_EVENT_OFF);
2323
2324         /* stop all pipes */
2325         HASHMAP_FOREACH(object, card->object_map, iter) {
2326                 grdrm_crtc *crtc;
2327
2328                 if (object->type != GRDRM_TYPE_CRTC)
2329                         continue;
2330
2331                 crtc = crtc_from_object(object);
2332                 crtc->applied = false;
2333                 if (crtc->pipe)
2334                         grdev_pipe_ready(&crtc->pipe->base, false);
2335         }
2336 }
2337
2338 static int grdrm_card_open(grdrm_card *card, int dev_fd) {
2339         _cleanup_(grdev_session_unpinp) grdev_session *pin = NULL;
2340         _cleanup_close_ int fd = dev_fd;
2341         struct drm_get_cap cap;
2342         int r, flags;
2343
2344         assert(card);
2345         assert(dev_fd >= 0);
2346         assert(card->fd != dev_fd);
2347
2348         pin = grdev_session_pin(card->base.session);
2349         grdrm_card_close(card);
2350
2351         log_debug("grdrm: %s/%s: open", card->base.session->name, card->base.name);
2352
2353         r = fd_nonblock(fd, true);
2354         if (r < 0)
2355                 return r;
2356
2357         r = fd_cloexec(fd, true);
2358         if (r < 0)
2359                 return r;
2360
2361         flags = fcntl(fd, F_GETFL, 0);
2362         if (flags < 0)
2363                 return -errno;
2364         if ((flags & O_ACCMODE) != O_RDWR)
2365                 return -EACCES;
2366
2367         r = sd_event_add_io(card->base.session->context->event,
2368                             &card->fd_src,
2369                             fd,
2370                             EPOLLHUP | EPOLLERR | EPOLLIN,
2371                             grdrm_card_io_fn,
2372                             card);
2373         if (r < 0)
2374                 return r;
2375
2376         sd_event_source_set_enabled(card->fd_src, SD_EVENT_OFF);
2377
2378         card->hotplug = true;
2379         card->fd = fd;
2380         fd = -1;
2381
2382         /* cache DUMB_BUFFER capability */
2383         cap.capability = DRM_CAP_DUMB_BUFFER;
2384         cap.value = 0;
2385         r = ioctl(card->fd, DRM_IOCTL_GET_CAP, &cap);
2386         card->cap_dumb = r >= 0 && cap.value;
2387         if (r < 0)
2388                 log_debug("grdrm: %s/%s: cannot retrieve DUMB_BUFFER capability: %s",
2389                           card->base.session->name, card->base.name, strerror(-r));
2390         else if (!card->cap_dumb)
2391                 log_debug("grdrm: %s/%s: DUMB_BUFFER capability not supported",
2392                           card->base.session->name, card->base.name);
2393
2394         /* cache TIMESTAMP_MONOTONIC capability */
2395         cap.capability = DRM_CAP_TIMESTAMP_MONOTONIC;
2396         cap.value = 0;
2397         r = ioctl(card->fd, DRM_IOCTL_GET_CAP, &cap);
2398         card->cap_monotonic = r >= 0 && cap.value;
2399         if (r < 0)
2400                 log_debug("grdrm: %s/%s: cannot retrieve TIMESTAMP_MONOTONIC capability: %s",
2401                           card->base.session->name, card->base.name, strerror(-r));
2402         else if (!card->cap_monotonic)
2403                 log_debug("grdrm: %s/%s: TIMESTAMP_MONOTONIC is disabled globally, fix this NOW!",
2404                           card->base.session->name, card->base.name);
2405
2406         return 0;
2407 }
2408
2409 static void grdrm_card_close(grdrm_card *card) {
2410         grdrm_object *object;
2411
2412         if (card->fd < 0)
2413                 return;
2414
2415         log_debug("grdrm: %s/%s: close", card->base.session->name, card->base.name);
2416
2417         grdrm_card_disable(card);
2418
2419         card->fd_src = sd_event_source_unref(card->fd_src);
2420         card->fd = safe_close(card->fd);
2421
2422         grdev_session_pin(card->base.session);
2423         while ((object = hashmap_first(card->object_map)))
2424                 grdrm_object_free(object);
2425         grdev_session_unpin(card->base.session);
2426 }
2427
2428 static bool grdrm_card_async(grdrm_card *card, int r) {
2429         switch (r) {
2430         case -EACCES:
2431                 /* If we get EACCES on runtime DRM calls, we lost DRM-Master
2432                  * (or we did something terribly wrong). Immediately disable
2433                  * the card, so we stop all pipes and wait to be activated
2434                  * again. */
2435                 grdrm_card_disable(card);
2436                 break;
2437         case -ENOENT:
2438                 /* DRM objects can be hotplugged at any time. If an object is
2439                  * removed that we use, we remember that state so a following
2440                  * call can test for this.
2441                  * Note that we also get a uevent as followup, this will resync
2442                  * the whole device. */
2443                 card->async_hotplug = true;
2444                 break;
2445         }
2446
2447         return !card->ready;
2448 }
2449
2450 /*
2451  * Unmanaged Cards
2452  * The unmanaged DRM card opens the device node for a given DRM device
2453  * directly (/dev/dri/cardX) and thus needs sufficient privileges. It opens
2454  * the device only if we really require it and releases it as soon as we're
2455  * disabled or closed.
2456  * The unmanaged element can be used in all situations where you have direct
2457  * access to DRM device nodes. Unlike managed DRM elements, it can be used
2458  * outside of user sessions and in emergency situations where logind is not
2459  * available.
2460  */
2461
2462 static void unmanaged_card_enable(grdev_card *basecard) {
2463         unmanaged_card *cu = unmanaged_card_from_base(basecard);
2464         int r, fd;
2465
2466         if (cu->card.fd < 0) {
2467                 /* try open on activation if it failed during allocation */
2468                 fd = open(cu->devnode, O_RDWR | O_CLOEXEC | O_NOCTTY | O_NONBLOCK);
2469                 if (fd < 0) {
2470                         /* not fatal; simply ignore the device */
2471                         log_debug("grdrm: %s/%s: cannot open node %s: %m",
2472                                   basecard->session->name, basecard->name, cu->devnode);
2473                         return;
2474                 }
2475
2476                 /* we might already be DRM-Master by open(); that's fine */
2477
2478                 r = grdrm_card_open(&cu->card, fd);
2479                 if (r < 0) {
2480                         log_debug("grdrm: %s/%s: cannot open: %s",
2481                                   basecard->session->name, basecard->name, strerror(-r));
2482                         return;
2483                 }
2484         }
2485
2486         r = ioctl(cu->card.fd, DRM_IOCTL_SET_MASTER, 0);
2487         if (r < 0) {
2488                 log_debug("grdrm: %s/%s: cannot acquire DRM-Master: %m",
2489                           basecard->session->name, basecard->name);
2490                 return;
2491         }
2492
2493         grdrm_card_enable(&cu->card);
2494 }
2495
2496 static void unmanaged_card_disable(grdev_card *basecard) {
2497         unmanaged_card *cu = unmanaged_card_from_base(basecard);
2498
2499         grdrm_card_disable(&cu->card);
2500 }
2501
2502 static int unmanaged_card_new(grdev_card **out, grdev_session *session, struct udev_device *ud) {
2503         _cleanup_(grdev_card_freep) grdev_card *basecard = NULL;
2504         char name[GRDRM_CARD_NAME_MAX];
2505         unmanaged_card *cu;
2506         const char *devnode;
2507         dev_t devnum;
2508         int r, fd;
2509
2510         assert_return(session, -EINVAL);
2511         assert_return(ud, -EINVAL);
2512
2513         devnode = udev_device_get_devnode(ud);
2514         devnum = udev_device_get_devnum(ud);
2515         if (!devnode || devnum == 0)
2516                 return -ENODEV;
2517
2518         grdrm_name(name, devnum);
2519
2520         cu = new0(unmanaged_card, 1);
2521         if (!cu)
2522                 return -ENOMEM;
2523
2524         basecard = &cu->card.base;
2525         cu->card = GRDRM_CARD_INIT(&unmanaged_card_vtable, session);
2526
2527         cu->devnode = strdup(devnode);
2528         if (!cu->devnode)
2529                 return -ENOMEM;
2530
2531         r = grdrm_card_add(&cu->card, name);
2532         if (r < 0)
2533                 return r;
2534
2535         /* try to open but ignore errors */
2536         fd = open(cu->devnode, O_RDWR | O_CLOEXEC | O_NOCTTY | O_NONBLOCK);
2537         if (fd < 0) {
2538                 /* not fatal; allow uaccess based control on activation */
2539                 log_debug("grdrm: %s/%s: cannot open node %s: %m",
2540                           basecard->session->name, basecard->name, cu->devnode);
2541         } else {
2542                 /* We might get DRM-Master implicitly on open(); drop it immediately
2543                  * so we acquire it only once we're actually enabled. We don't
2544                  * really care whether this call fails or not, but lets log any
2545                  * weird errors, anyway. */
2546                 r = ioctl(fd, DRM_IOCTL_DROP_MASTER, 0);
2547                 if (r < 0 && errno != EACCES && errno != EINVAL)
2548                         log_debug("grdrm: %s/%s: cannot drop DRM-Master: %m",
2549                                   basecard->session->name, basecard->name);
2550
2551                 r = grdrm_card_open(&cu->card, fd);
2552                 if (r < 0)
2553                         log_debug("grdrm: %s/%s: cannot open: %s",
2554                                   basecard->session->name, basecard->name, strerror(-r));
2555         }
2556
2557         if (out)
2558                 *out = basecard;
2559         basecard = NULL;
2560         return 0;
2561 }
2562
2563 static void unmanaged_card_free(grdev_card *basecard) {
2564         unmanaged_card *cu = unmanaged_card_from_base(basecard);
2565
2566         assert(!basecard->enabled);
2567
2568         grdrm_card_close(&cu->card);
2569         grdrm_card_destroy(&cu->card);
2570         free(cu->devnode);
2571         free(cu);
2572 }
2573
2574 static const grdev_card_vtable unmanaged_card_vtable = {
2575         .free                   = unmanaged_card_free,
2576         .enable                 = unmanaged_card_enable,
2577         .disable                = unmanaged_card_disable,
2578         .commit                 = grdrm_card_commit,
2579         .restore                = grdrm_card_restore,
2580 };
2581
2582 /*
2583  * Managed Cards
2584  * The managed DRM card uses systemd-logind to acquire DRM devices. This
2585  * means, we do not open the device node /dev/dri/cardX directly. Instead,
2586  * logind passes us a file-descriptor whenever our session is activated. Thus,
2587  * we don't need access to the device node directly.
2588  * Furthermore, whenever the session is put asleep, logind revokes the
2589  * file-descriptor so we loose access to the device.
2590  * Managed DRM cards should be preferred over unmanaged DRM cards whenever
2591  * you run inside a user session with exclusive device access.
2592  */
2593
2594 static void managed_card_enable(grdev_card *card) {
2595         managed_card *cm = managed_card_from_base(card);
2596
2597         /* If the device is manually re-enabled, we try to resume our card
2598          * management. Note that we have no control over DRM-Master and the fd,
2599          * so we have to take over the state from the last logind event. */
2600
2601         if (cm->master)
2602                 grdrm_card_enable(&cm->card);
2603 }
2604
2605 static void managed_card_disable(grdev_card *card) {
2606         managed_card *cm = managed_card_from_base(card);
2607
2608         /* If the device is manually disabled, we keep the FD but put our card
2609          * management asleep. This way, we can wake up at any time, but don't
2610          * touch the device while asleep. */
2611
2612         grdrm_card_disable(&cm->card);
2613 }
2614
2615 static int managed_card_pause_device_fn(sd_bus *bus,
2616                                         sd_bus_message *signal,
2617                                         void *userdata,
2618                                         sd_bus_error *ret_error) {
2619         managed_card *cm = userdata;
2620         grdev_session *session = cm->card.base.session;
2621         uint32_t major, minor;
2622         const char *mode;
2623         int r;
2624
2625         /*
2626          * We get PauseDevice() signals from logind whenever a device we
2627          * requested was, or is about to be, paused. Arguments are major/minor
2628          * number of the device and the mode of the operation.
2629          * In case the event is not about our device, we ignore it. Otherwise,
2630          * we treat it as asynchronous DRM-DROP-MASTER. Note that we might have
2631          * already handled an EACCES error from a modeset ioctl, in which case
2632          * we already disabled the device.
2633          *
2634          * @mode can be one of the following:
2635          *   "pause": The device is about to be paused. We must react
2636          *            immediately and respond with PauseDeviceComplete(). Once
2637          *            we replied, logind will pause the device. Note that
2638          *            logind might apply any kind of timeout and force pause
2639          *            the device if we don't respond in a timely manner. In
2640          *            this case, we will receive a second PauseDevice event
2641          *            with @mode set to "force" (or similar).
2642          *   "force": The device was disabled forecfully by logind. DRM-Master
2643          *            was already dropped. This is just an asynchronous
2644          *            notification so we can put the device asleep (in case
2645          *            we didn't already notice the dropped DRM-Master).
2646          *    "gone": This is like "force" but is sent if the device was
2647          *            paused due to a device-removal event.
2648          *
2649          * We always handle PauseDevice signals as "force" as we properly
2650          * support asynchronously dropping DRM-Master, anyway. But in case
2651          * logind sent mode "pause", we also call PauseDeviceComplete() to
2652          * immediately acknowledge the request.
2653          */
2654
2655         r = sd_bus_message_read(signal, "uus", &major, &minor, &mode);
2656         if (r < 0) {
2657                 log_debug("grdrm: %s/%s: erroneous PauseDevice signal",
2658                           session->name, cm->card.base.name);
2659                 return 0;
2660         }
2661
2662         /* not our device? */
2663         if (makedev(major, minor) != cm->devnum)
2664                 return 0;
2665
2666         cm->master = false;
2667         grdrm_card_disable(&cm->card);
2668
2669         if (streq(mode, "pause")) {
2670                 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2671
2672                 /*
2673                  * Sending PauseDeviceComplete() is racy if logind triggers the
2674                  * timeout. That is, if we take too long and logind pauses the
2675                  * device by sending a forced PauseDevice, our
2676                  * PauseDeviceComplete call will be stray. That's fine, though.
2677                  * logind ignores such stray calls. Only if logind also sent a
2678                  * further PauseDevice() signal, it might match our call
2679                  * incorrectly to the newer PauseDevice(). That's fine, too, as
2680                  * we handle that event asynchronously, anyway. Therefore,
2681                  * whatever happens, we're fine. Yay!
2682                  */
2683
2684                 r = sd_bus_message_new_method_call(session->context->sysbus,
2685                                                    &m,
2686                                                    "org.freedesktop.login1",
2687                                                    session->path,
2688                                                    "org.freedesktop.login1.Session",
2689                                                    "PauseDeviceComplete");
2690                 if (r >= 0) {
2691                         r = sd_bus_message_append(m, "uu", major, minor);
2692                         if (r >= 0)
2693                                 r = sd_bus_send(session->context->sysbus, m, NULL);
2694                 }
2695
2696                 if (r < 0)
2697                         log_debug("grdrm: %s/%s: cannot send PauseDeviceComplete: %s",
2698                                   session->name, cm->card.base.name, strerror(-r));
2699         }
2700
2701         return 0;
2702 }
2703
2704 static int managed_card_resume_device_fn(sd_bus *bus,
2705                                          sd_bus_message *signal,
2706                                          void *userdata,
2707                                          sd_bus_error *ret_error) {
2708         managed_card *cm = userdata;
2709         grdev_session *session = cm->card.base.session;
2710         uint32_t major, minor;
2711         int r, fd;
2712
2713         /*
2714          * We get ResumeDevice signals whenever logind resumed a previously
2715          * paused device. The arguments contain the major/minor number of the
2716          * related device and a new file-descriptor for the freshly opened
2717          * device-node.
2718          * If the signal is not about our device, we simply ignore it.
2719          * Otherwise, we immediately resume the device. Note that we drop the
2720          * new file-descriptor as we already have one from TakeDevice(). logind
2721          * preserves the file-context across pause/resume for DRM but only
2722          * drops/acquires DRM-Master accordingly. This way, our context (like
2723          * DRM-FBs and BOs) is preserved.
2724          */
2725
2726         r = sd_bus_message_read(signal, "uuh", &major, &minor, &fd);
2727         if (r < 0) {
2728                 log_debug("grdrm: %s/%s: erroneous ResumeDevice signal",
2729                           session->name, cm->card.base.name);
2730                 return 0;
2731         }
2732
2733         /* not our device? */
2734         if (makedev(major, minor) != cm->devnum)
2735                 return 0;
2736
2737         if (cm->card.fd < 0) {
2738                 /* This shouldn't happen. We should already own an FD from
2739                  * TakeDevice(). However, lets be safe and use this FD in case
2740                  * we really don't have one. There is no harm in doing this
2741                  * and our code works fine this way. */
2742                 fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
2743                 if (fd < 0) {
2744                         log_debug("grdrm: %s/%s: cannot duplicate fd: %m",
2745                                   session->name, cm->card.base.name);
2746                         return 0;
2747                 }
2748
2749                 r = grdrm_card_open(&cm->card, fd);
2750                 if (r < 0) {
2751                         log_debug("grdrm: %s/%s: cannot open: %s",
2752                                   session->name, cm->card.base.name, strerror(-r));
2753                         return 0;
2754                 }
2755         }
2756
2757         cm->master = true;
2758         if (cm->card.base.enabled)
2759                 grdrm_card_enable(&cm->card);
2760
2761         return 0;
2762 }
2763
2764 static int managed_card_setup_bus(managed_card *cm) {
2765         grdev_session *session = cm->card.base.session;
2766         _cleanup_free_ char *match = NULL;
2767         int r;
2768
2769         match = strjoin("type='signal',"
2770                         "sender='org.freedesktop.login1',"
2771                         "interface='org.freedesktop.login1.Session',"
2772                         "member='PauseDevice',"
2773                         "path='", session->path, "'",
2774                         NULL);
2775         if (!match)
2776                 return -ENOMEM;
2777
2778         r = sd_bus_add_match(session->context->sysbus,
2779                              &cm->slot_pause_device,
2780                              match,
2781                              managed_card_pause_device_fn,
2782                              cm);
2783         if (r < 0)
2784                 return r;
2785
2786         free(match);
2787         match = strjoin("type='signal',"
2788                         "sender='org.freedesktop.login1',"
2789                         "interface='org.freedesktop.login1.Session',"
2790                         "member='ResumeDevice',"
2791                         "path='", session->path, "'",
2792                         NULL);
2793         if (!match)
2794                 return -ENOMEM;
2795
2796         r = sd_bus_add_match(session->context->sysbus,
2797                              &cm->slot_resume_device,
2798                              match,
2799                              managed_card_resume_device_fn,
2800                              cm);
2801         if (r < 0)
2802                 return r;
2803
2804         return 0;
2805 }
2806
2807 static int managed_card_take_device_fn(sd_bus *bus,
2808                                        sd_bus_message *reply,
2809                                        void *userdata,
2810                                        sd_bus_error *ret_error) {
2811         managed_card *cm = userdata;
2812         grdev_session *session = cm->card.base.session;
2813         int r, paused, fd;
2814
2815         cm->slot_take_device = sd_bus_slot_unref(cm->slot_take_device);
2816
2817         if (sd_bus_message_is_method_error(reply, NULL)) {
2818                 const sd_bus_error *error = sd_bus_message_get_error(reply);
2819
2820                 log_debug("grdrm: %s/%s: TakeDevice failed: %s: %s",
2821                           session->name, cm->card.base.name, error->name, error->message);
2822                 return 0;
2823         }
2824
2825         cm->acquired = true;
2826
2827         r = sd_bus_message_read(reply, "hb", &fd, &paused);
2828         if (r < 0) {
2829                 log_debug("grdrm: %s/%s: erroneous TakeDevice reply",
2830                           session->name, cm->card.base.name);
2831                 return 0;
2832         }
2833
2834         fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
2835         if (fd < 0) {
2836                 log_debug("grdrm: %s/%s: cannot duplicate fd: %m",
2837                           session->name, cm->card.base.name);
2838                 return 0;
2839         }
2840
2841         r = grdrm_card_open(&cm->card, fd);
2842         if (r < 0) {
2843                 log_debug("grdrm: %s/%s: cannot open: %s",
2844                           session->name, cm->card.base.name, strerror(-r));
2845                 return 0;
2846         }
2847
2848         if (!paused && cm->card.base.enabled)
2849                 grdrm_card_enable(&cm->card);
2850
2851         return 0;
2852 }
2853
2854 static void managed_card_take_device(managed_card *cm) {
2855         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2856         grdev_session *session = cm->card.base.session;
2857         int r;
2858
2859         r = sd_bus_message_new_method_call(session->context->sysbus,
2860                                            &m,
2861                                            "org.freedesktop.login1",
2862                                            session->path,
2863                                            "org.freedesktop.login1.Session",
2864                                            "TakeDevice");
2865         if (r < 0)
2866                 goto error;
2867
2868         r = sd_bus_message_append(m, "uu", major(cm->devnum), minor(cm->devnum));
2869         if (r < 0)
2870                 goto error;
2871
2872         r = sd_bus_call_async(session->context->sysbus,
2873                               &cm->slot_take_device,
2874                               m,
2875                               managed_card_take_device_fn,
2876                               cm,
2877                               0);
2878         if (r < 0)
2879                 goto error;
2880
2881         cm->requested = true;
2882         return;
2883
2884 error:
2885         log_debug("grdrm: %s/%s: cannot send TakeDevice request: %s",
2886                   session->name, cm->card.base.name, strerror(-r));
2887 }
2888
2889 static void managed_card_release_device(managed_card *cm) {
2890         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2891         grdev_session *session = cm->card.base.session;
2892         int r;
2893
2894         /*
2895          * If TakeDevice() is pending or was successful, make sure to
2896          * release the device again. We don't care for return-values,
2897          * so send it without waiting or callbacks.
2898          * If a failed TakeDevice() is pending, but someone else took
2899          * the device on the same bus-connection, we might incorrectly
2900          * release their device. This is an unlikely race, though.
2901          * Furthermore, you really shouldn't have two users of the
2902          * controller-API on the same session, on the same devices, *AND* on
2903          * the same bus-connection. So we don't care for that race..
2904          */
2905
2906         grdrm_card_close(&cm->card);
2907         cm->requested = false;
2908
2909         if (!cm->acquired && !cm->slot_take_device)
2910                 return;
2911
2912         cm->slot_take_device = sd_bus_slot_unref(cm->slot_take_device);
2913         cm->acquired = false;
2914
2915         r = sd_bus_message_new_method_call(session->context->sysbus,
2916                                            &m,
2917                                            "org.freedesktop.login1",
2918                                            session->path,
2919                                            "org.freedesktop.login1.Session",
2920                                            "ReleaseDevice");
2921         if (r >= 0) {
2922                 r = sd_bus_message_append(m, "uu", major(cm->devnum), minor(cm->devnum));
2923                 if (r >= 0)
2924                         r = sd_bus_send(session->context->sysbus, m, NULL);
2925         }
2926
2927         if (r < 0 && r != -ENOTCONN)
2928                 log_debug("grdrm: %s/%s: cannot send ReleaseDevice: %s",
2929                           session->name, cm->card.base.name, strerror(-r));
2930 }
2931
2932 static int managed_card_new(grdev_card **out, grdev_session *session, struct udev_device *ud) {
2933         _cleanup_(grdev_card_freep) grdev_card *basecard = NULL;
2934         char name[GRDRM_CARD_NAME_MAX];
2935         managed_card *cm;
2936         dev_t devnum;
2937         int r;
2938
2939         assert_return(session, -EINVAL);
2940         assert_return(session->managed, -EINVAL);
2941         assert_return(session->context->sysbus, -EINVAL);
2942         assert_return(ud, -EINVAL);
2943
2944         devnum = udev_device_get_devnum(ud);
2945         if (devnum == 0)
2946                 return -ENODEV;
2947
2948         grdrm_name(name, devnum);
2949
2950         cm = new0(managed_card, 1);
2951         if (!cm)
2952                 return -ENOMEM;
2953
2954         basecard = &cm->card.base;
2955         cm->card = GRDRM_CARD_INIT(&managed_card_vtable, session);
2956         cm->devnum = devnum;
2957
2958         r = managed_card_setup_bus(cm);
2959         if (r < 0)
2960                 return r;
2961
2962         r = grdrm_card_add(&cm->card, name);
2963         if (r < 0)
2964                 return r;
2965
2966         managed_card_take_device(cm);
2967
2968         if (out)
2969                 *out = basecard;
2970         basecard = NULL;
2971         return 0;
2972 }
2973
2974 static void managed_card_free(grdev_card *basecard) {
2975         managed_card *cm = managed_card_from_base(basecard);
2976
2977         assert(!basecard->enabled);
2978
2979         managed_card_release_device(cm);
2980         cm->slot_resume_device = sd_bus_slot_unref(cm->slot_resume_device);
2981         cm->slot_pause_device = sd_bus_slot_unref(cm->slot_pause_device);
2982         grdrm_card_destroy(&cm->card);
2983         free(cm);
2984 }
2985
2986 static const grdev_card_vtable managed_card_vtable = {
2987         .free                   = managed_card_free,
2988         .enable                 = managed_card_enable,
2989         .disable                = managed_card_disable,
2990         .commit                 = grdrm_card_commit,
2991         .restore                = grdrm_card_restore,
2992 };
2993
2994 /*
2995  * Generic Constructor
2996  * Instead of relying on the caller to choose between managed and unmanaged
2997  * DRM devices, the grdev_drm_new() constructor does that for you (by
2998  * looking at session->managed).
2999  */
3000
3001 bool grdev_is_drm_card(grdev_card *basecard) {
3002         return basecard && (basecard->vtable == &unmanaged_card_vtable ||
3003                             basecard->vtable == &managed_card_vtable);
3004 }
3005
3006 grdev_card *grdev_find_drm_card(grdev_session *session, dev_t devnum) {
3007         char name[GRDRM_CARD_NAME_MAX];
3008
3009         assert_return(session, NULL);
3010         assert_return(devnum != 0, NULL);
3011
3012         grdrm_name(name, devnum);
3013         return grdev_find_card(session, name);
3014 }
3015
3016 int grdev_drm_card_new(grdev_card **out, grdev_session *session, struct udev_device *ud) {
3017         assert_return(session, -EINVAL);
3018         assert_return(ud, -EINVAL);
3019
3020         return session->managed ? managed_card_new(out, session, ud) : unmanaged_card_new(out, session, ud);
3021 }
3022
3023 void grdev_drm_card_hotplug(grdev_card *basecard, struct udev_device *ud) {
3024         const char *p, *action;
3025         grdrm_card *card;
3026         dev_t devnum;
3027
3028         assert(basecard);
3029         assert(grdev_is_drm_card(basecard));
3030         assert(ud);
3031
3032         card = grdrm_card_from_base(basecard);
3033
3034         action = udev_device_get_action(ud);
3035         if (!action || streq(action, "add") || streq(action, "remove")) {
3036                 /* If we get add/remove events on DRM nodes without devnum, we
3037                  * got hotplugged DRM objects so refresh the device. */
3038                 devnum = udev_device_get_devnum(ud);
3039                 if (devnum == 0) {
3040                         card->hotplug = true;
3041                         grdrm_card_hotplug(card);
3042                 }
3043         } else if (streq_ptr(action, "change")) {
3044                 /* A change event with HOTPLUG=1 is sent whenever a connector
3045                  * changed state. Refresh the device to update our state. */
3046                 p = udev_device_get_property_value(ud, "HOTPLUG");
3047                 if (streq_ptr(p, "1")) {
3048                         card->hotplug = true;
3049                         grdrm_card_hotplug(card);
3050                 }
3051         }
3052 }