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->base.free_fn)
1446                 fb->base.free_fn(fb->base.data.ptr);
1447
1448         if (fb->id > 0 && fb->card->fd >= 0) {
1449                 r = ioctl(fb->card->fd, DRM_IOCTL_MODE_RMFB, fb->id);
1450                 if (r < 0)
1451                         log_debug("grdrm: %s: cannot delete framebuffer %" PRIu32 ": %m",
1452                                   fb->card->base.name, fb->id);
1453         }
1454
1455         for (i = 0; i < ELEMENTSOF(fb->handles); ++i) {
1456                 struct drm_mode_destroy_dumb destroy_dumb = { };
1457
1458                 if (fb->base.maps[i] != MAP_FAILED)
1459                         munmap(fb->base.maps[i], fb->sizes[i]);
1460
1461                 if (fb->handles[i] > 0 && fb->card->fd >= 0) {
1462                         destroy_dumb.handle = fb->handles[i];
1463                         r = ioctl(fb->card->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_dumb);
1464                         if (r < 0)
1465                                 log_debug("grdrm: %s: cannot destroy dumb-buffer %" PRIu32 ": %m",
1466                                           fb->card->base.name, fb->handles[i]);
1467                 }
1468         }
1469
1470         free(fb);
1471
1472         return NULL;
1473 }
1474
1475 /*
1476  * Pipes
1477  */
1478
1479 static void grdrm_pipe_name(char *out, grdrm_crtc *crtc) {
1480         /* @out must be at least of size GRDRM_PIPE_NAME_MAX */
1481         sprintf(out, "%s/%" PRIu32, crtc->object.card->base.name, crtc->object.id);
1482 }
1483
1484 static int grdrm_pipe_new(grdrm_pipe **out, grdrm_crtc *crtc, struct drm_mode_modeinfo *mode, size_t n_fbs) {
1485         _cleanup_(grdev_pipe_freep) grdev_pipe *basepipe = NULL;
1486         grdrm_card *card = crtc->object.card;
1487         char name[GRDRM_PIPE_NAME_MAX];
1488         grdrm_pipe *pipe;
1489         int r;
1490
1491         assert_return(crtc, -EINVAL);
1492         assert_return(grdev_is_drm_card(&card->base), -EINVAL);
1493
1494         pipe = new0(grdrm_pipe, 1);
1495         if (!pipe)
1496                 return -ENOMEM;
1497
1498         basepipe = &pipe->base;
1499         pipe->base = GRDEV_PIPE_INIT(&grdrm_pipe_vtable, &card->base);
1500         pipe->crtc = crtc;
1501         pipe->base.width = mode->hdisplay;
1502         pipe->base.height = mode->vdisplay;
1503         pipe->base.vrefresh = mode->vrefresh ? : 25;
1504
1505         grdrm_pipe_name(name, crtc);
1506         r = grdev_pipe_add(&pipe->base, name, n_fbs);
1507         if (r < 0)
1508                 return r;
1509
1510         if (out)
1511                 *out = pipe;
1512         basepipe = NULL;
1513         return 0;
1514 }
1515
1516 static void grdrm_pipe_free(grdev_pipe *basepipe) {
1517         grdrm_pipe *pipe = grdrm_pipe_from_base(basepipe);
1518         size_t i;
1519
1520         assert(pipe->crtc);
1521
1522         for (i = 0; i < pipe->base.max_fbs; ++i)
1523                 if (pipe->base.fbs[i])
1524                         grdrm_fb_free(fb_from_base(pipe->base.fbs[i]));
1525
1526         free(pipe);
1527 }
1528
1529 static grdev_fb *grdrm_pipe_target(grdev_pipe *basepipe) {
1530         grdrm_fb *fb;
1531         size_t i;
1532
1533         if (!basepipe->back) {
1534                 for (i = 0; i < basepipe->max_fbs; ++i) {
1535                         if (!basepipe->fbs[i])
1536                                 continue;
1537
1538                         fb = fb_from_base(basepipe->fbs[i]);
1539                         if (&fb->base == basepipe->front)
1540                                 continue;
1541                         if (basepipe->flipping && fb->flipid)
1542                                 continue;
1543
1544                         basepipe->back = &fb->base;
1545                         break;
1546                 }
1547         }
1548
1549         return basepipe->back;
1550 }
1551
1552 static void grdrm_pipe_enable(grdev_pipe *basepipe) {
1553         grdrm_pipe *pipe = grdrm_pipe_from_base(basepipe);
1554
1555         pipe->crtc->applied = false;
1556 }
1557
1558 static void grdrm_pipe_disable(grdev_pipe *basepipe) {
1559         grdrm_pipe *pipe = grdrm_pipe_from_base(basepipe);
1560
1561         pipe->crtc->applied = false;
1562 }
1563
1564 static const grdev_pipe_vtable grdrm_pipe_vtable = {
1565         .free                   = grdrm_pipe_free,
1566         .target                 = grdrm_pipe_target,
1567         .enable                 = grdrm_pipe_enable,
1568         .disable                = grdrm_pipe_disable,
1569 };
1570
1571 /*
1572  * Cards
1573  */
1574
1575 static void grdrm_name(char *out, dev_t devnum) {
1576         /* @out must be at least of size GRDRM_CARD_NAME_MAX */
1577         sprintf(out, "drm/%u:%u", major(devnum), minor(devnum));
1578 }
1579
1580 static void grdrm_card_print(grdrm_card *card) {
1581         grdrm_object *object;
1582         grdrm_crtc *crtc;
1583         grdrm_encoder *encoder;
1584         grdrm_connector *connector;
1585         grdrm_plane *plane;
1586         Iterator iter;
1587         uint32_t i;
1588         char *p, *buf;
1589
1590         log_debug("grdrm: %s: state dump", card->base.name);
1591
1592         log_debug("  crtcs:");
1593         HASHMAP_FOREACH(object, card->object_map, iter) {
1594                 if (object->type != GRDRM_TYPE_CRTC)
1595                         continue;
1596
1597                 crtc = crtc_from_object(object);
1598                 log_debug("    (id: %u index: %d)", object->id, object->index);
1599
1600                 if (crtc->kern.mode_set)
1601                         log_debug("      mode: %dx%d", crtc->kern.mode.hdisplay, crtc->kern.mode.vdisplay);
1602                 else
1603                         log_debug("      mode: <none>");
1604         }
1605
1606         log_debug("  encoders:");
1607         HASHMAP_FOREACH(object, card->object_map, iter) {
1608                 if (object->type != GRDRM_TYPE_ENCODER)
1609                         continue;
1610
1611                 encoder = encoder_from_object(object);
1612                 log_debug("    (id: %u index: %d)", object->id, object->index);
1613
1614                 if (encoder->kern.used_crtc)
1615                         log_debug("      crtc: %u", encoder->kern.used_crtc);
1616                 else
1617                         log_debug("      crtc: <none>");
1618
1619                 buf = malloc((DECIMAL_STR_MAX(uint32_t) + 1) * encoder->kern.n_crtcs + 1);
1620                 if (buf) {
1621                         buf[0] = 0;
1622                         p = buf;
1623
1624                         for (i = 0; i < encoder->kern.n_crtcs; ++i)
1625                                 p += sprintf(p, " %" PRIu32, encoder->kern.crtcs[i]);
1626
1627                         log_debug("      possible crtcs:%s", buf);
1628                         free(buf);
1629                 }
1630
1631                 buf = malloc((DECIMAL_STR_MAX(uint32_t) + 1) * encoder->kern.n_clones + 1);
1632                 if (buf) {
1633                         buf[0] = 0;
1634                         p = buf;
1635
1636                         for (i = 0; i < encoder->kern.n_clones; ++i)
1637                                 p += sprintf(p, " %" PRIu32, encoder->kern.clones[i]);
1638
1639                         log_debug("      possible clones:%s", buf);
1640                         free(buf);
1641                 }
1642         }
1643
1644         log_debug("  connectors:");
1645         HASHMAP_FOREACH(object, card->object_map, iter) {
1646                 if (object->type != GRDRM_TYPE_CONNECTOR)
1647                         continue;
1648
1649                 connector = connector_from_object(object);
1650                 log_debug("    (id: %u index: %d)", object->id, object->index);
1651                 log_debug("      type: %" PRIu32 "-%" PRIu32 " connection: %" PRIu32 " subpixel: %" PRIu32 " extents: %" PRIu32 "x%" PRIu32,
1652                           connector->kern.type, connector->kern.type_id, connector->kern.connection, connector->kern.subpixel,
1653                           connector->kern.mm_width, connector->kern.mm_height);
1654
1655                 if (connector->kern.used_encoder)
1656                         log_debug("      encoder: %" PRIu32, connector->kern.used_encoder);
1657                 else
1658                         log_debug("      encoder: <none>");
1659
1660                 buf = malloc((DECIMAL_STR_MAX(uint32_t) + 1) * connector->kern.n_encoders + 1);
1661                 if (buf) {
1662                         buf[0] = 0;
1663                         p = buf;
1664
1665                         for (i = 0; i < connector->kern.n_encoders; ++i)
1666                                 p += sprintf(p, " %" PRIu32, connector->kern.encoders[i]);
1667
1668                         log_debug("      possible encoders:%s", buf);
1669                         free(buf);
1670                 }
1671
1672                 for (i = 0; i < connector->kern.n_modes; ++i) {
1673                         struct drm_mode_modeinfo *mode = &connector->kern.modes[i];
1674                         log_debug("      mode: %" PRIu32 "x%" PRIu32, mode->hdisplay, mode->vdisplay);
1675                 }
1676         }
1677
1678         log_debug("  planes:");
1679         HASHMAP_FOREACH(object, card->object_map, iter) {
1680                 if (object->type != GRDRM_TYPE_PLANE)
1681                         continue;
1682
1683                 plane = plane_from_object(object);
1684                 log_debug("    (id: %u index: %d)", object->id, object->index);
1685                 log_debug("      gamma-size: %" PRIu32, plane->kern.gamma_size);
1686
1687                 if (plane->kern.used_crtc)
1688                         log_debug("      crtc: %" PRIu32, plane->kern.used_crtc);
1689                 else
1690                         log_debug("      crtc: <none>");
1691
1692                 buf = malloc((DECIMAL_STR_MAX(uint32_t) + 1) * plane->kern.n_crtcs + 1);
1693                 if (buf) {
1694                         buf[0] = 0;
1695                         p = buf;
1696
1697                         for (i = 0; i < plane->kern.n_crtcs; ++i)
1698                                 p += sprintf(p, " %" PRIu32, plane->kern.crtcs[i]);
1699
1700                         log_debug("      possible crtcs:%s", buf);
1701                         free(buf);
1702                 }
1703
1704                 buf = malloc((DECIMAL_STR_MAX(unsigned int) + 3) * plane->kern.n_formats + 1);
1705                 if (buf) {
1706                         buf[0] = 0;
1707                         p = buf;
1708
1709                         for (i = 0; i < plane->kern.n_formats; ++i)
1710                                 p += sprintf(p, " 0x%x", (unsigned int)plane->kern.formats[i]);
1711
1712                         log_debug("      possible formats:%s", buf);
1713                         free(buf);
1714                 }
1715         }
1716 }
1717
1718 static int grdrm_card_resync(grdrm_card *card) {
1719         _cleanup_free_ uint32_t *crtc_ids = NULL, *encoder_ids = NULL, *connector_ids = NULL, *plane_ids = NULL;
1720         uint32_t allocated = 0;
1721         grdrm_object *object;
1722         Iterator iter;
1723         size_t tries;
1724         int r;
1725
1726         assert(card);
1727
1728         card->async_hotplug = false;
1729         allocated = 0;
1730
1731         /* mark existing objects for possible removal */
1732         HASHMAP_FOREACH(object, card->object_map, iter)
1733                 object->present = false;
1734
1735         for (tries = 0; tries < GRDRM_MAX_TRIES; ++tries) {
1736                 struct drm_mode_get_plane_res pres;
1737                 struct drm_mode_card_res res;
1738                 uint32_t i, max;
1739
1740                 if (allocated < card->max_ids) {
1741                         free(crtc_ids);
1742                         free(encoder_ids);
1743                         free(connector_ids);
1744                         free(plane_ids);
1745                         crtc_ids = new0(uint32_t, card->max_ids);
1746                         encoder_ids = new0(uint32_t, card->max_ids);
1747                         connector_ids = new0(uint32_t, card->max_ids);
1748                         plane_ids = new0(uint32_t, card->max_ids);
1749
1750                         if (!crtc_ids || !encoder_ids || !connector_ids || !plane_ids)
1751                                 return -ENOMEM;
1752
1753                         allocated = card->max_ids;
1754                 }
1755
1756                 zero(res);
1757                 res.crtc_id_ptr = PTR_TO_UINT64(crtc_ids);
1758                 res.connector_id_ptr = PTR_TO_UINT64(connector_ids);
1759                 res.encoder_id_ptr = PTR_TO_UINT64(encoder_ids);
1760                 res.count_crtcs = allocated;
1761                 res.count_encoders = allocated;
1762                 res.count_connectors = allocated;
1763
1764                 r = ioctl(card->fd, DRM_IOCTL_MODE_GETRESOURCES, &res);
1765                 if (r < 0) {
1766                         r = -errno;
1767                         log_debug("grdrm: %s: cannot retrieve drm resources: %m", card->base.name);
1768                         return r;
1769                 }
1770
1771                 zero(pres);
1772                 pres.plane_id_ptr = PTR_TO_UINT64(plane_ids);
1773                 pres.count_planes = allocated;
1774
1775                 r = ioctl(card->fd, DRM_IOCTL_MODE_GETPLANERESOURCES, &pres);
1776                 if (r < 0) {
1777                         r = -errno;
1778                         log_debug("grdrm: %s: cannot retrieve drm plane-resources: %m", card->base.name);
1779                         return r;
1780                 }
1781
1782                 max = MAX(MAX(res.count_crtcs, res.count_encoders),
1783                           MAX(res.count_connectors, pres.count_planes));
1784                 if (max > allocated) {
1785                         uint32_t n;
1786
1787                         n = ALIGN_POWER2(max);
1788                         if (!n || n > UINT16_MAX) {
1789                                 log_debug("grdrm: %s: excessive DRM resource limit: %" PRIu32, card->base.name, max);
1790                                 return -ERANGE;
1791                         }
1792
1793                         /* retry with resized buffers */
1794                         card->max_ids = n;
1795                         continue;
1796                 }
1797
1798                 /* mark available objects as present */
1799
1800                 for (i = 0; i < res.count_crtcs; ++i) {
1801                         object = grdrm_find_object(card, crtc_ids[i]);
1802                         if (object && object->type == GRDRM_TYPE_CRTC) {
1803                                 object->present = true;
1804                                 object->index = i;
1805                                 crtc_ids[i] = 0;
1806                         }
1807                 }
1808
1809                 for (i = 0; i < res.count_encoders; ++i) {
1810                         object = grdrm_find_object(card, encoder_ids[i]);
1811                         if (object && object->type == GRDRM_TYPE_ENCODER) {
1812                                 object->present = true;
1813                                 object->index = i;
1814                                 encoder_ids[i] = 0;
1815                         }
1816                 }
1817
1818                 for (i = 0; i < res.count_connectors; ++i) {
1819                         object = grdrm_find_object(card, connector_ids[i]);
1820                         if (object && object->type == GRDRM_TYPE_CONNECTOR) {
1821                                 object->present = true;
1822                                 object->index = i;
1823                                 connector_ids[i] = 0;
1824                         }
1825                 }
1826
1827                 for (i = 0; i < pres.count_planes; ++i) {
1828                         object = grdrm_find_object(card, plane_ids[i]);
1829                         if (object && object->type == GRDRM_TYPE_PLANE) {
1830                                 object->present = true;
1831                                 object->index = i;
1832                                 plane_ids[i] = 0;
1833                         }
1834                 }
1835
1836                 /* drop removed objects */
1837
1838                 HASHMAP_FOREACH(object, card->object_map, iter)
1839                         if (!object->present)
1840                                 grdrm_object_free(object);
1841
1842                 /* add new objects */
1843
1844                 card->n_crtcs = res.count_crtcs;
1845                 for (i = 0; i < res.count_crtcs; ++i) {
1846                         if (crtc_ids[i] < 1)
1847                                 continue;
1848
1849                         r = grdrm_crtc_new(NULL, card, crtc_ids[i], i);
1850                         if (r < 0)
1851                                 return r;
1852                 }
1853
1854                 card->n_encoders = res.count_encoders;
1855                 for (i = 0; i < res.count_encoders; ++i) {
1856                         if (encoder_ids[i] < 1)
1857                                 continue;
1858
1859                         r = grdrm_encoder_new(NULL, card, encoder_ids[i], i);
1860                         if (r < 0)
1861                                 return r;
1862                 }
1863
1864                 card->n_connectors = res.count_connectors;
1865                 for (i = 0; i < res.count_connectors; ++i) {
1866                         if (connector_ids[i] < 1)
1867                                 continue;
1868
1869                         r = grdrm_connector_new(NULL, card, connector_ids[i], i);
1870                         if (r < 0)
1871                                 return r;
1872                 }
1873
1874                 card->n_planes = pres.count_planes;
1875                 for (i = 0; i < pres.count_planes; ++i) {
1876                         if (plane_ids[i] < 1)
1877                                 continue;
1878
1879                         r = grdrm_plane_new(NULL, card, plane_ids[i], i);
1880                         if (r < 0)
1881                                 return r;
1882                 }
1883
1884                 /* re-sync objects after object_map is synced */
1885
1886                 HASHMAP_FOREACH(object, card->object_map, iter) {
1887                         switch (object->type) {
1888                         case GRDRM_TYPE_CRTC:
1889                                 r = grdrm_crtc_resync(crtc_from_object(object));
1890                                 break;
1891                         case GRDRM_TYPE_ENCODER:
1892                                 r = grdrm_encoder_resync(encoder_from_object(object));
1893                                 break;
1894                         case GRDRM_TYPE_CONNECTOR:
1895                                 r = grdrm_connector_resync(connector_from_object(object));
1896                                 break;
1897                         case GRDRM_TYPE_PLANE:
1898                                 r = grdrm_plane_resync(plane_from_object(object));
1899                                 break;
1900                         default:
1901                                 assert_not_reached("grdrm: invalid object type");
1902                                 r = 0;
1903                         }
1904
1905                         if (r < 0)
1906                                 return r;
1907
1908                         if (card->async_hotplug)
1909                                 break;
1910                 }
1911
1912                 /* if modeset objects change during sync, start over */
1913                 if (card->async_hotplug) {
1914                         card->async_hotplug = false;
1915                         continue;
1916                 }
1917
1918                 /* cache crtc/connector relationship */
1919                 HASHMAP_FOREACH(object, card->object_map, iter) {
1920                         grdrm_connector *connector;
1921                         grdrm_encoder *encoder;
1922                         grdrm_crtc *crtc;
1923
1924                         if (object->type != GRDRM_TYPE_CONNECTOR)
1925                                 continue;
1926
1927                         connector = connector_from_object(object);
1928                         if (connector->kern.connection != 1 || connector->kern.used_encoder < 1)
1929                                 continue;
1930
1931                         object = grdrm_find_object(card, connector->kern.used_encoder);
1932                         if (!object || object->type != GRDRM_TYPE_ENCODER)
1933                                 continue;
1934
1935                         encoder = encoder_from_object(object);
1936                         if (encoder->kern.used_crtc < 1)
1937                                 continue;
1938
1939                         object = grdrm_find_object(card, encoder->kern.used_crtc);
1940                         if (!object || object->type != GRDRM_TYPE_CRTC)
1941                                 continue;
1942
1943                         crtc = crtc_from_object(object);
1944                         assert(crtc->kern.n_used_connectors < crtc->kern.max_used_connectors);
1945                         crtc->kern.used_connectors[crtc->kern.n_used_connectors++] = connector->object.id;
1946                 }
1947
1948                 /* cache old crtc settings for later restore */
1949                 HASHMAP_FOREACH(object, card->object_map, iter) {
1950                         grdrm_crtc *crtc;
1951
1952                         if (object->type != GRDRM_TYPE_CRTC)
1953                                 continue;
1954
1955                         crtc = crtc_from_object(object);
1956
1957                         /* Save data if it is the first time we refresh the CRTC. This data can
1958                          * be used optionally to restore any previous configuration. For
1959                          * instance, it allows us to restore VT configurations after we close
1960                          * our session again. */
1961                         if (!crtc->old.set) {
1962                                 crtc->old.fb = crtc->kern.used_fb;
1963                                 crtc->old.fb_x = crtc->kern.fb_offset_x;
1964                                 crtc->old.fb_y = crtc->kern.fb_offset_y;
1965                                 crtc->old.gamma = crtc->kern.gamma_size;
1966                                 crtc->old.n_connectors = crtc->kern.n_used_connectors;
1967                                 if (crtc->old.n_connectors)
1968                                         memcpy(crtc->old.connectors, crtc->kern.used_connectors, sizeof(uint32_t) * crtc->old.n_connectors);
1969                                 crtc->old.mode_set = crtc->kern.mode_set;
1970                                 crtc->old.mode = crtc->kern.mode;
1971                                 crtc->old.set = true;
1972                         }
1973                 }
1974
1975                 /* everything synced */
1976                 break;
1977         }
1978
1979         if (tries >= GRDRM_MAX_TRIES) {
1980                 /*
1981                  * Ugh! We were unable to sync the DRM card state due to heavy
1982                  * hotplugging. This should never happen, so print a debug
1983                  * message and bail out. The next uevent will trigger
1984                  * this again.
1985                  */
1986
1987                 log_debug("grdrm: %s: hotplug-storm when syncing card", card->base.name);
1988                 return -EFAULT;
1989         }
1990
1991         return 0;
1992 }
1993
1994 static bool card_configure_crtc(grdrm_crtc *crtc, grdrm_connector *connector) {
1995         grdrm_card *card = crtc->object.card;
1996         grdrm_encoder *encoder;
1997         grdrm_object *object;
1998         uint32_t i, j;
1999
2000         if (crtc->object.assigned || connector->object.assigned)
2001                 return false;
2002         if (connector->kern.connection != 1)
2003                 return false;
2004
2005         for (i = 0; i < connector->kern.n_encoders; ++i) {
2006                 object = grdrm_find_object(card, connector->kern.encoders[i]);
2007                 if (!object || object->type != GRDRM_TYPE_ENCODER)
2008                         continue;
2009
2010                 encoder = encoder_from_object(object);
2011                 for (j = 0; j < encoder->kern.n_crtcs; ++j) {
2012                         if (encoder->kern.crtcs[j] == crtc->object.id) {
2013                                 grdrm_crtc_assign(crtc, connector);
2014                                 return true;
2015                         }
2016                 }
2017         }
2018
2019         return false;
2020 }
2021
2022 static void grdrm_card_configure(grdrm_card *card) {
2023         /*
2024          * Modeset Configuration
2025          * This is where we update our modeset configuration and assign
2026          * connectors to CRTCs. This means, each connector that we want to
2027          * enable needs a CRTC, disabled (or unavailable) connectors are left
2028          * alone in the dark. Once all CRTCs are assigned, the remaining CRTCs
2029          * are disabled.
2030          * Sounds trivial, but there're several caveats:
2031          *
2032          *   * Multiple connectors can be driven by the same CRTC. This is
2033          *     known as 'hardware clone mode'. Advantage over software clone
2034          *     mode is that only a single CRTC is needed to drive multiple
2035          *     displays. However, few hardware supports this and it's a huge
2036          *     headache to configure on dynamic demands. Therefore, we only
2037          *     support it if configured statically beforehand.
2038          *
2039          *   * CRTCs are not created equal. Some might be much more poweful
2040          *     than others, including more advanced plane support. So far, our
2041          *     CRTC selection is random. You need to supply static
2042          *     configuration if you want special setups. So far, there is no
2043          *     proper way to do advanced CRTC selection on dynamic demands. It
2044          *     is not really clear which demands require what CRTC, so, like
2045          *     everyone else, we do random CRTC selection unless explicitly
2046          *     states otherwise.
2047          *
2048          *   * Each Connector has a list of possible encoders that can drive
2049          *     it, and each encoder has a list of possible CRTCs. If this graph
2050          *     is a tree, assignment is trivial. However, if not, we cannot
2051          *     reliably decide on configurations beforehand. The encoder is
2052          *     always selected by the kernel, so we have to actually set a mode
2053          *     to know which encoder is used. There is no way to ask the kernel
2054          *     whether a given configuration is possible. This will change with
2055          *     atomic-modesetting, but until then, we keep our configurations
2056          *     simple and assume they work all just fine. If one fails
2057          *     unexpectedly, we print a warning and disable it.
2058          *
2059          * Configuring a card consists of several steps:
2060          *
2061          *  1) First of all, we apply any user-configuration. If a user wants
2062          *     a fixed configuration, we apply it and preserve it.
2063          *     So far, we don't support user configuration files, so this step
2064          *     is skipped.
2065          *
2066          *  2) Secondly, we need to apply any quirks from hwdb. Some hardware
2067          *     might only support limited configurations or require special
2068          *     CRTC/Connector mappings. We read this from hwdb and apply it, if
2069          *     present.
2070          *     So far, we don't support this as there is no known quirk, so
2071          *     this step is skipped.
2072          *
2073          *  3) As deep modesets are expensive, we try to avoid them if
2074          *     possible. Therefore, we read the current configuration from the
2075          *     kernel and try to preserve it, if compatible with our demands.
2076          *     If not, we break it and reassign it in a following step.
2077          *
2078          *  4) The main step involves configuring all remaining objects. By
2079          *     default, all available connectors are enabled, except for those
2080          *     disabled by user-configuration. We lookup a suitable CRTC for
2081          *     each connector and assign them. As there might be more
2082          *     connectors than CRTCs, we apply some ordering so users can
2083          *     select which connectors are more important right now.
2084          *     So far, we only apply the default ordering, more might be added
2085          *     in the future.
2086          */
2087
2088         grdrm_object *object;
2089         grdrm_crtc *crtc;
2090         Iterator i, j;
2091
2092         /* clear assignments */
2093         HASHMAP_FOREACH(object, card->object_map, i)
2094                 object->assigned = false;
2095
2096         /* preserve existing configurations */
2097         HASHMAP_FOREACH(object, card->object_map, i) {
2098                 if (object->type != GRDRM_TYPE_CRTC || object->assigned)
2099                         continue;
2100
2101                 crtc = crtc_from_object(object);
2102
2103                 if (crtc->applied) {
2104                         /* If our mode is set, preserve it. If no connector is
2105                          * set, modeset either failed or the pipe is unused. In
2106                          * both cases, leave it alone. It might be tried again
2107                          * below in case there're remaining connectors.
2108                          * Otherwise, try restoring the assignments. If they
2109                          * are no longer valid, leave the pipe untouched. */
2110
2111                         if (crtc->set.n_connectors < 1)
2112                                 continue;
2113
2114                         assert(crtc->set.n_connectors == 1);
2115
2116                         object = grdrm_find_object(card, crtc->set.connectors[0]);
2117                         if (!object || object->type != GRDRM_TYPE_CONNECTOR)
2118                                 continue;
2119
2120                         card_configure_crtc(crtc, connector_from_object(object));
2121                 } else if (crtc->kern.mode_set && crtc->kern.n_used_connectors != 1) {
2122                         /* If our mode is not set on the pipe, we know the kern
2123                          * information is valid. Try keeping it. If it's not
2124                          * possible, leave the pipe untouched for later
2125                          * assignements. */
2126
2127                         object = grdrm_find_object(card, crtc->kern.used_connectors[0]);
2128                         if (!object || object->type != GRDRM_TYPE_CONNECTOR)
2129                                 continue;
2130
2131                         card_configure_crtc(crtc, connector_from_object(object));
2132                 }
2133         }
2134
2135         /* assign remaining objects */
2136         HASHMAP_FOREACH(object, card->object_map, i) {
2137                 if (object->type != GRDRM_TYPE_CRTC || object->assigned)
2138                         continue;
2139
2140                 crtc = crtc_from_object(object);
2141
2142                 HASHMAP_FOREACH(object, card->object_map, j) {
2143                         if (object->type != GRDRM_TYPE_CONNECTOR)
2144                                 continue;
2145
2146                         if (card_configure_crtc(crtc, connector_from_object(object)))
2147                                 break;
2148                 }
2149
2150                 if (!crtc->object.assigned)
2151                         grdrm_crtc_assign(crtc, NULL);
2152         }
2153
2154         /* expose configuration */
2155         HASHMAP_FOREACH(object, card->object_map, i) {
2156                 if (object->type != GRDRM_TYPE_CRTC)
2157                         continue;
2158
2159                 grdrm_crtc_expose(crtc_from_object(object));
2160         }
2161 }
2162
2163 static void grdrm_card_hotplug(grdrm_card *card) {
2164         int r;
2165
2166         assert(card);
2167
2168         if (!card->running)
2169                 return;
2170
2171         log_debug("grdrm: %s/%s: reconfigure card", card->base.session->name, card->base.name);
2172
2173         card->ready = false;
2174         r = grdrm_card_resync(card);
2175         if (r < 0) {
2176                 log_debug("grdrm: %s/%s: cannot re-sync card: %s",
2177                           card->base.session->name, card->base.name, strerror(-r));
2178                 return;
2179         }
2180
2181         grdev_session_pin(card->base.session);
2182
2183         /* debug statement to print card information */
2184         if (0)
2185                 grdrm_card_print(card);
2186
2187         grdrm_card_configure(card);
2188         card->ready = true;
2189         card->hotplug = false;
2190
2191         grdev_session_unpin(card->base.session);
2192 }
2193
2194 static int grdrm_card_io_fn(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2195         grdrm_card *card = userdata;
2196         struct drm_event_vblank *vblank;
2197         struct drm_event *event;
2198         uint32_t id, counter;
2199         grdrm_object *object;
2200         char buf[4096];
2201         size_t len;
2202         ssize_t l;
2203
2204         if (revents & (EPOLLHUP | EPOLLERR)) {
2205                 /* Immediately close device on HUP; no need to flush pending
2206                  * data.. there're no events we care about here. */
2207                 log_debug("grdrm: %s/%s: HUP", card->base.session->name, card->base.name);
2208                 grdrm_card_close(card);
2209                 return 0;
2210         }
2211
2212         if (revents & (EPOLLIN)) {
2213                 l = read(card->fd, buf, sizeof(buf));
2214                 if (l < 0) {
2215                         if (errno == EAGAIN || errno == EINTR)
2216                                 return 0;
2217
2218                         log_debug("grdrm: %s/%s: read error: %m", card->base.session->name, card->base.name);
2219                         grdrm_card_close(card);
2220                         return 0;
2221                 }
2222
2223                 for (len = l; len > 0; len -= event->length) {
2224                         event = (void*)buf;
2225
2226                         if (len < sizeof(*event) || len < event->length) {
2227                                 log_debug("grdrm: %s/%s: truncated event", card->base.session->name, card->base.name);
2228                                 break;
2229                         }
2230
2231                         switch (event->type) {
2232                         case DRM_EVENT_FLIP_COMPLETE:
2233                                 vblank = (void*)event;
2234                                 if (event->length < sizeof(*vblank)) {
2235                                         log_debug("grdrm: %s/%s: truncated vblank event", card->base.session->name, card->base.name);
2236                                         break;
2237                                 }
2238
2239                                 grdrm_decode_vblank_data(vblank->user_data, &id, &counter);
2240                                 object = grdrm_find_object(card, id);
2241                                 if (!object || object->type != GRDRM_TYPE_CRTC)
2242                                         break;
2243
2244                                 grdrm_crtc_flip_complete(crtc_from_object(object), counter, vblank);
2245                                 break;
2246                         }
2247                 }
2248         }
2249
2250         return 0;
2251 }
2252
2253 static int grdrm_card_add(grdrm_card *card, const char *name) {
2254         assert(card);
2255         assert(card->fd < 0);
2256
2257         card->object_map = hashmap_new(&trivial_hash_ops);
2258         if (!card->object_map)
2259                 return -ENOMEM;
2260
2261         return grdev_card_add(&card->base, name);
2262 }
2263
2264 static void grdrm_card_destroy(grdrm_card *card) {
2265         assert(card);
2266         assert(!card->running);
2267         assert(card->fd < 0);
2268         assert(hashmap_size(card->object_map) == 0);
2269
2270         hashmap_free(card->object_map);
2271 }
2272
2273 static void grdrm_card_commit(grdev_card *basecard) {
2274         grdrm_card *card = grdrm_card_from_base(basecard);
2275         grdrm_object *object;
2276         Iterator iter;
2277
2278         HASHMAP_FOREACH(object, card->object_map, iter) {
2279                 if (!card->ready)
2280                         break;
2281
2282                 if (object->type != GRDRM_TYPE_CRTC)
2283                         continue;
2284
2285                 grdrm_crtc_commit(crtc_from_object(object));
2286         }
2287 }
2288
2289 static void grdrm_card_restore(grdev_card *basecard) {
2290         grdrm_card *card = grdrm_card_from_base(basecard);
2291         grdrm_object *object;
2292         Iterator iter;
2293
2294         HASHMAP_FOREACH(object, card->object_map, iter) {
2295                 if (!card->ready)
2296                         break;
2297
2298                 if (object->type != GRDRM_TYPE_CRTC)
2299                         continue;
2300
2301                 grdrm_crtc_restore(crtc_from_object(object));
2302         }
2303 }
2304
2305 static void grdrm_card_enable(grdrm_card *card) {
2306         assert(card);
2307
2308         if (card->fd < 0 || card->running)
2309                 return;
2310
2311         /* ignore cards without DUMB_BUFFER capability */
2312         if (!card->cap_dumb)
2313                 return;
2314
2315         assert(card->fd_src);
2316
2317         log_debug("grdrm: %s/%s: enable", card->base.session->name, card->base.name);
2318
2319         card->running = true;
2320         sd_event_source_set_enabled(card->fd_src, SD_EVENT_ON);
2321         grdrm_card_hotplug(card);
2322 }
2323
2324 static void grdrm_card_disable(grdrm_card *card) {
2325         grdrm_object *object;
2326         Iterator iter;
2327
2328         assert(card);
2329
2330         if (card->fd < 0 || !card->running)
2331                 return;
2332
2333         assert(card->fd_src);
2334
2335         log_debug("grdrm: %s/%s: disable", card->base.session->name, card->base.name);
2336
2337         card->running = false;
2338         card->ready = false;
2339         sd_event_source_set_enabled(card->fd_src, SD_EVENT_OFF);
2340
2341         /* stop all pipes */
2342         HASHMAP_FOREACH(object, card->object_map, iter) {
2343                 grdrm_crtc *crtc;
2344
2345                 if (object->type != GRDRM_TYPE_CRTC)
2346                         continue;
2347
2348                 crtc = crtc_from_object(object);
2349                 crtc->applied = false;
2350                 if (crtc->pipe)
2351                         grdev_pipe_ready(&crtc->pipe->base, false);
2352         }
2353 }
2354
2355 static int grdrm_card_open(grdrm_card *card, int dev_fd) {
2356         _cleanup_(grdev_session_unpinp) grdev_session *pin = NULL;
2357         _cleanup_close_ int fd = dev_fd;
2358         struct drm_get_cap cap;
2359         int r, flags;
2360
2361         assert(card);
2362         assert(dev_fd >= 0);
2363         assert(card->fd != dev_fd);
2364
2365         pin = grdev_session_pin(card->base.session);
2366         grdrm_card_close(card);
2367
2368         log_debug("grdrm: %s/%s: open", card->base.session->name, card->base.name);
2369
2370         r = fd_nonblock(fd, true);
2371         if (r < 0)
2372                 return r;
2373
2374         r = fd_cloexec(fd, true);
2375         if (r < 0)
2376                 return r;
2377
2378         flags = fcntl(fd, F_GETFL, 0);
2379         if (flags < 0)
2380                 return -errno;
2381         if ((flags & O_ACCMODE) != O_RDWR)
2382                 return -EACCES;
2383
2384         r = sd_event_add_io(card->base.session->context->event,
2385                             &card->fd_src,
2386                             fd,
2387                             EPOLLHUP | EPOLLERR | EPOLLIN,
2388                             grdrm_card_io_fn,
2389                             card);
2390         if (r < 0)
2391                 return r;
2392
2393         sd_event_source_set_enabled(card->fd_src, SD_EVENT_OFF);
2394
2395         card->hotplug = true;
2396         card->fd = fd;
2397         fd = -1;
2398
2399         /* cache DUMB_BUFFER capability */
2400         cap.capability = DRM_CAP_DUMB_BUFFER;
2401         cap.value = 0;
2402         r = ioctl(card->fd, DRM_IOCTL_GET_CAP, &cap);
2403         card->cap_dumb = r >= 0 && cap.value;
2404         if (r < 0)
2405                 log_debug("grdrm: %s/%s: cannot retrieve DUMB_BUFFER capability: %s",
2406                           card->base.session->name, card->base.name, strerror(-r));
2407         else if (!card->cap_dumb)
2408                 log_debug("grdrm: %s/%s: DUMB_BUFFER capability not supported",
2409                           card->base.session->name, card->base.name);
2410
2411         /* cache TIMESTAMP_MONOTONIC capability */
2412         cap.capability = DRM_CAP_TIMESTAMP_MONOTONIC;
2413         cap.value = 0;
2414         r = ioctl(card->fd, DRM_IOCTL_GET_CAP, &cap);
2415         card->cap_monotonic = r >= 0 && cap.value;
2416         if (r < 0)
2417                 log_debug("grdrm: %s/%s: cannot retrieve TIMESTAMP_MONOTONIC capability: %s",
2418                           card->base.session->name, card->base.name, strerror(-r));
2419         else if (!card->cap_monotonic)
2420                 log_debug("grdrm: %s/%s: TIMESTAMP_MONOTONIC is disabled globally, fix this NOW!",
2421                           card->base.session->name, card->base.name);
2422
2423         return 0;
2424 }
2425
2426 static void grdrm_card_close(grdrm_card *card) {
2427         grdrm_object *object;
2428
2429         if (card->fd < 0)
2430                 return;
2431
2432         log_debug("grdrm: %s/%s: close", card->base.session->name, card->base.name);
2433
2434         grdrm_card_disable(card);
2435
2436         card->fd_src = sd_event_source_unref(card->fd_src);
2437         card->fd = safe_close(card->fd);
2438
2439         grdev_session_pin(card->base.session);
2440         while ((object = hashmap_first(card->object_map)))
2441                 grdrm_object_free(object);
2442         grdev_session_unpin(card->base.session);
2443 }
2444
2445 static bool grdrm_card_async(grdrm_card *card, int r) {
2446         switch (r) {
2447         case -EACCES:
2448                 /* If we get EACCES on runtime DRM calls, we lost DRM-Master
2449                  * (or we did something terribly wrong). Immediately disable
2450                  * the card, so we stop all pipes and wait to be activated
2451                  * again. */
2452                 grdrm_card_disable(card);
2453                 break;
2454         case -ENOENT:
2455                 /* DRM objects can be hotplugged at any time. If an object is
2456                  * removed that we use, we remember that state so a following
2457                  * call can test for this.
2458                  * Note that we also get a uevent as followup, this will resync
2459                  * the whole device. */
2460                 card->async_hotplug = true;
2461                 break;
2462         }
2463
2464         return !card->ready;
2465 }
2466
2467 /*
2468  * Unmanaged Cards
2469  * The unmanaged DRM card opens the device node for a given DRM device
2470  * directly (/dev/dri/cardX) and thus needs sufficient privileges. It opens
2471  * the device only if we really require it and releases it as soon as we're
2472  * disabled or closed.
2473  * The unmanaged element can be used in all situations where you have direct
2474  * access to DRM device nodes. Unlike managed DRM elements, it can be used
2475  * outside of user sessions and in emergency situations where logind is not
2476  * available.
2477  */
2478
2479 static void unmanaged_card_enable(grdev_card *basecard) {
2480         unmanaged_card *cu = unmanaged_card_from_base(basecard);
2481         int r, fd;
2482
2483         if (cu->card.fd < 0) {
2484                 /* try open on activation if it failed during allocation */
2485                 fd = open(cu->devnode, O_RDWR | O_CLOEXEC | O_NOCTTY | O_NONBLOCK);
2486                 if (fd < 0) {
2487                         /* not fatal; simply ignore the device */
2488                         log_debug("grdrm: %s/%s: cannot open node %s: %m",
2489                                   basecard->session->name, basecard->name, cu->devnode);
2490                         return;
2491                 }
2492
2493                 /* we might already be DRM-Master by open(); that's fine */
2494
2495                 r = grdrm_card_open(&cu->card, fd);
2496                 if (r < 0) {
2497                         log_debug("grdrm: %s/%s: cannot open: %s",
2498                                   basecard->session->name, basecard->name, strerror(-r));
2499                         return;
2500                 }
2501         }
2502
2503         r = ioctl(cu->card.fd, DRM_IOCTL_SET_MASTER, 0);
2504         if (r < 0) {
2505                 log_debug("grdrm: %s/%s: cannot acquire DRM-Master: %m",
2506                           basecard->session->name, basecard->name);
2507                 return;
2508         }
2509
2510         grdrm_card_enable(&cu->card);
2511 }
2512
2513 static void unmanaged_card_disable(grdev_card *basecard) {
2514         unmanaged_card *cu = unmanaged_card_from_base(basecard);
2515
2516         grdrm_card_disable(&cu->card);
2517 }
2518
2519 static int unmanaged_card_new(grdev_card **out, grdev_session *session, struct udev_device *ud) {
2520         _cleanup_(grdev_card_freep) grdev_card *basecard = NULL;
2521         char name[GRDRM_CARD_NAME_MAX];
2522         unmanaged_card *cu;
2523         const char *devnode;
2524         dev_t devnum;
2525         int r, fd;
2526
2527         assert_return(session, -EINVAL);
2528         assert_return(ud, -EINVAL);
2529
2530         devnode = udev_device_get_devnode(ud);
2531         devnum = udev_device_get_devnum(ud);
2532         if (!devnode || devnum == 0)
2533                 return -ENODEV;
2534
2535         grdrm_name(name, devnum);
2536
2537         cu = new0(unmanaged_card, 1);
2538         if (!cu)
2539                 return -ENOMEM;
2540
2541         basecard = &cu->card.base;
2542         cu->card = GRDRM_CARD_INIT(&unmanaged_card_vtable, session);
2543
2544         cu->devnode = strdup(devnode);
2545         if (!cu->devnode)
2546                 return -ENOMEM;
2547
2548         r = grdrm_card_add(&cu->card, name);
2549         if (r < 0)
2550                 return r;
2551
2552         /* try to open but ignore errors */
2553         fd = open(cu->devnode, O_RDWR | O_CLOEXEC | O_NOCTTY | O_NONBLOCK);
2554         if (fd < 0) {
2555                 /* not fatal; allow uaccess based control on activation */
2556                 log_debug("grdrm: %s/%s: cannot open node %s: %m",
2557                           basecard->session->name, basecard->name, cu->devnode);
2558         } else {
2559                 /* We might get DRM-Master implicitly on open(); drop it immediately
2560                  * so we acquire it only once we're actually enabled. We don't
2561                  * really care whether this call fails or not, but lets log any
2562                  * weird errors, anyway. */
2563                 r = ioctl(fd, DRM_IOCTL_DROP_MASTER, 0);
2564                 if (r < 0 && errno != EACCES && errno != EINVAL)
2565                         log_debug("grdrm: %s/%s: cannot drop DRM-Master: %m",
2566                                   basecard->session->name, basecard->name);
2567
2568                 r = grdrm_card_open(&cu->card, fd);
2569                 if (r < 0)
2570                         log_debug("grdrm: %s/%s: cannot open: %s",
2571                                   basecard->session->name, basecard->name, strerror(-r));
2572         }
2573
2574         if (out)
2575                 *out = basecard;
2576         basecard = NULL;
2577         return 0;
2578 }
2579
2580 static void unmanaged_card_free(grdev_card *basecard) {
2581         unmanaged_card *cu = unmanaged_card_from_base(basecard);
2582
2583         assert(!basecard->enabled);
2584
2585         grdrm_card_close(&cu->card);
2586         grdrm_card_destroy(&cu->card);
2587         free(cu->devnode);
2588         free(cu);
2589 }
2590
2591 static const grdev_card_vtable unmanaged_card_vtable = {
2592         .free                   = unmanaged_card_free,
2593         .enable                 = unmanaged_card_enable,
2594         .disable                = unmanaged_card_disable,
2595         .commit                 = grdrm_card_commit,
2596         .restore                = grdrm_card_restore,
2597 };
2598
2599 /*
2600  * Managed Cards
2601  * The managed DRM card uses systemd-logind to acquire DRM devices. This
2602  * means, we do not open the device node /dev/dri/cardX directly. Instead,
2603  * logind passes us a file-descriptor whenever our session is activated. Thus,
2604  * we don't need access to the device node directly.
2605  * Furthermore, whenever the session is put asleep, logind revokes the
2606  * file-descriptor so we loose access to the device.
2607  * Managed DRM cards should be preferred over unmanaged DRM cards whenever
2608  * you run inside a user session with exclusive device access.
2609  */
2610
2611 static void managed_card_enable(grdev_card *card) {
2612         managed_card *cm = managed_card_from_base(card);
2613
2614         /* If the device is manually re-enabled, we try to resume our card
2615          * management. Note that we have no control over DRM-Master and the fd,
2616          * so we have to take over the state from the last logind event. */
2617
2618         if (cm->master)
2619                 grdrm_card_enable(&cm->card);
2620 }
2621
2622 static void managed_card_disable(grdev_card *card) {
2623         managed_card *cm = managed_card_from_base(card);
2624
2625         /* If the device is manually disabled, we keep the FD but put our card
2626          * management asleep. This way, we can wake up at any time, but don't
2627          * touch the device while asleep. */
2628
2629         grdrm_card_disable(&cm->card);
2630 }
2631
2632 static int managed_card_pause_device_fn(sd_bus *bus,
2633                                         sd_bus_message *signal,
2634                                         void *userdata,
2635                                         sd_bus_error *ret_error) {
2636         managed_card *cm = userdata;
2637         grdev_session *session = cm->card.base.session;
2638         uint32_t major, minor;
2639         const char *mode;
2640         int r;
2641
2642         /*
2643          * We get PauseDevice() signals from logind whenever a device we
2644          * requested was, or is about to be, paused. Arguments are major/minor
2645          * number of the device and the mode of the operation.
2646          * In case the event is not about our device, we ignore it. Otherwise,
2647          * we treat it as asynchronous DRM-DROP-MASTER. Note that we might have
2648          * already handled an EACCES error from a modeset ioctl, in which case
2649          * we already disabled the device.
2650          *
2651          * @mode can be one of the following:
2652          *   "pause": The device is about to be paused. We must react
2653          *            immediately and respond with PauseDeviceComplete(). Once
2654          *            we replied, logind will pause the device. Note that
2655          *            logind might apply any kind of timeout and force pause
2656          *            the device if we don't respond in a timely manner. In
2657          *            this case, we will receive a second PauseDevice event
2658          *            with @mode set to "force" (or similar).
2659          *   "force": The device was disabled forecfully by logind. DRM-Master
2660          *            was already dropped. This is just an asynchronous
2661          *            notification so we can put the device asleep (in case
2662          *            we didn't already notice the dropped DRM-Master).
2663          *    "gone": This is like "force" but is sent if the device was
2664          *            paused due to a device-removal event.
2665          *
2666          * We always handle PauseDevice signals as "force" as we properly
2667          * support asynchronously dropping DRM-Master, anyway. But in case
2668          * logind sent mode "pause", we also call PauseDeviceComplete() to
2669          * immediately acknowledge the request.
2670          */
2671
2672         r = sd_bus_message_read(signal, "uus", &major, &minor, &mode);
2673         if (r < 0) {
2674                 log_debug("grdrm: %s/%s: erroneous PauseDevice signal",
2675                           session->name, cm->card.base.name);
2676                 return 0;
2677         }
2678
2679         /* not our device? */
2680         if (makedev(major, minor) != cm->devnum)
2681                 return 0;
2682
2683         cm->master = false;
2684         grdrm_card_disable(&cm->card);
2685
2686         if (streq(mode, "pause")) {
2687                 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2688
2689                 /*
2690                  * Sending PauseDeviceComplete() is racy if logind triggers the
2691                  * timeout. That is, if we take too long and logind pauses the
2692                  * device by sending a forced PauseDevice, our
2693                  * PauseDeviceComplete call will be stray. That's fine, though.
2694                  * logind ignores such stray calls. Only if logind also sent a
2695                  * further PauseDevice() signal, it might match our call
2696                  * incorrectly to the newer PauseDevice(). That's fine, too, as
2697                  * we handle that event asynchronously, anyway. Therefore,
2698                  * whatever happens, we're fine. Yay!
2699                  */
2700
2701                 r = sd_bus_message_new_method_call(session->context->sysbus,
2702                                                    &m,
2703                                                    "org.freedesktop.login1",
2704                                                    session->path,
2705                                                    "org.freedesktop.login1.Session",
2706                                                    "PauseDeviceComplete");
2707                 if (r >= 0) {
2708                         r = sd_bus_message_append(m, "uu", major, minor);
2709                         if (r >= 0)
2710                                 r = sd_bus_send(session->context->sysbus, m, NULL);
2711                 }
2712
2713                 if (r < 0)
2714                         log_debug("grdrm: %s/%s: cannot send PauseDeviceComplete: %s",
2715                                   session->name, cm->card.base.name, strerror(-r));
2716         }
2717
2718         return 0;
2719 }
2720
2721 static int managed_card_resume_device_fn(sd_bus *bus,
2722                                          sd_bus_message *signal,
2723                                          void *userdata,
2724                                          sd_bus_error *ret_error) {
2725         managed_card *cm = userdata;
2726         grdev_session *session = cm->card.base.session;
2727         uint32_t major, minor;
2728         int r, fd;
2729
2730         /*
2731          * We get ResumeDevice signals whenever logind resumed a previously
2732          * paused device. The arguments contain the major/minor number of the
2733          * related device and a new file-descriptor for the freshly opened
2734          * device-node.
2735          * If the signal is not about our device, we simply ignore it.
2736          * Otherwise, we immediately resume the device. Note that we drop the
2737          * new file-descriptor as we already have one from TakeDevice(). logind
2738          * preserves the file-context across pause/resume for DRM but only
2739          * drops/acquires DRM-Master accordingly. This way, our context (like
2740          * DRM-FBs and BOs) is preserved.
2741          */
2742
2743         r = sd_bus_message_read(signal, "uuh", &major, &minor, &fd);
2744         if (r < 0) {
2745                 log_debug("grdrm: %s/%s: erroneous ResumeDevice signal",
2746                           session->name, cm->card.base.name);
2747                 return 0;
2748         }
2749
2750         /* not our device? */
2751         if (makedev(major, minor) != cm->devnum)
2752                 return 0;
2753
2754         if (cm->card.fd < 0) {
2755                 /* This shouldn't happen. We should already own an FD from
2756                  * TakeDevice(). However, lets be safe and use this FD in case
2757                  * we really don't have one. There is no harm in doing this
2758                  * and our code works fine this way. */
2759                 fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
2760                 if (fd < 0) {
2761                         log_debug("grdrm: %s/%s: cannot duplicate fd: %m",
2762                                   session->name, cm->card.base.name);
2763                         return 0;
2764                 }
2765
2766                 r = grdrm_card_open(&cm->card, fd);
2767                 if (r < 0) {
2768                         log_debug("grdrm: %s/%s: cannot open: %s",
2769                                   session->name, cm->card.base.name, strerror(-r));
2770                         return 0;
2771                 }
2772         }
2773
2774         cm->master = true;
2775         if (cm->card.base.enabled)
2776                 grdrm_card_enable(&cm->card);
2777
2778         return 0;
2779 }
2780
2781 static int managed_card_setup_bus(managed_card *cm) {
2782         grdev_session *session = cm->card.base.session;
2783         _cleanup_free_ char *match = NULL;
2784         int r;
2785
2786         match = strjoin("type='signal',"
2787                         "sender='org.freedesktop.login1',"
2788                         "interface='org.freedesktop.login1.Session',"
2789                         "member='PauseDevice',"
2790                         "path='", session->path, "'",
2791                         NULL);
2792         if (!match)
2793                 return -ENOMEM;
2794
2795         r = sd_bus_add_match(session->context->sysbus,
2796                              &cm->slot_pause_device,
2797                              match,
2798                              managed_card_pause_device_fn,
2799                              cm);
2800         if (r < 0)
2801                 return r;
2802
2803         free(match);
2804         match = strjoin("type='signal',"
2805                         "sender='org.freedesktop.login1',"
2806                         "interface='org.freedesktop.login1.Session',"
2807                         "member='ResumeDevice',"
2808                         "path='", session->path, "'",
2809                         NULL);
2810         if (!match)
2811                 return -ENOMEM;
2812
2813         r = sd_bus_add_match(session->context->sysbus,
2814                              &cm->slot_resume_device,
2815                              match,
2816                              managed_card_resume_device_fn,
2817                              cm);
2818         if (r < 0)
2819                 return r;
2820
2821         return 0;
2822 }
2823
2824 static int managed_card_take_device_fn(sd_bus *bus,
2825                                        sd_bus_message *reply,
2826                                        void *userdata,
2827                                        sd_bus_error *ret_error) {
2828         managed_card *cm = userdata;
2829         grdev_session *session = cm->card.base.session;
2830         int r, paused, fd;
2831
2832         cm->slot_take_device = sd_bus_slot_unref(cm->slot_take_device);
2833
2834         if (sd_bus_message_is_method_error(reply, NULL)) {
2835                 const sd_bus_error *error = sd_bus_message_get_error(reply);
2836
2837                 log_debug("grdrm: %s/%s: TakeDevice failed: %s: %s",
2838                           session->name, cm->card.base.name, error->name, error->message);
2839                 return 0;
2840         }
2841
2842         cm->acquired = true;
2843
2844         r = sd_bus_message_read(reply, "hb", &fd, &paused);
2845         if (r < 0) {
2846                 log_debug("grdrm: %s/%s: erroneous TakeDevice reply",
2847                           session->name, cm->card.base.name);
2848                 return 0;
2849         }
2850
2851         fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
2852         if (fd < 0) {
2853                 log_debug("grdrm: %s/%s: cannot duplicate fd: %m",
2854                           session->name, cm->card.base.name);
2855                 return 0;
2856         }
2857
2858         r = grdrm_card_open(&cm->card, fd);
2859         if (r < 0) {
2860                 log_debug("grdrm: %s/%s: cannot open: %s",
2861                           session->name, cm->card.base.name, strerror(-r));
2862                 return 0;
2863         }
2864
2865         if (!paused && cm->card.base.enabled)
2866                 grdrm_card_enable(&cm->card);
2867
2868         return 0;
2869 }
2870
2871 static void managed_card_take_device(managed_card *cm) {
2872         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2873         grdev_session *session = cm->card.base.session;
2874         int r;
2875
2876         r = sd_bus_message_new_method_call(session->context->sysbus,
2877                                            &m,
2878                                            "org.freedesktop.login1",
2879                                            session->path,
2880                                            "org.freedesktop.login1.Session",
2881                                            "TakeDevice");
2882         if (r < 0)
2883                 goto error;
2884
2885         r = sd_bus_message_append(m, "uu", major(cm->devnum), minor(cm->devnum));
2886         if (r < 0)
2887                 goto error;
2888
2889         r = sd_bus_call_async(session->context->sysbus,
2890                               &cm->slot_take_device,
2891                               m,
2892                               managed_card_take_device_fn,
2893                               cm,
2894                               0);
2895         if (r < 0)
2896                 goto error;
2897
2898         cm->requested = true;
2899         return;
2900
2901 error:
2902         log_debug("grdrm: %s/%s: cannot send TakeDevice request: %s",
2903                   session->name, cm->card.base.name, strerror(-r));
2904 }
2905
2906 static void managed_card_release_device(managed_card *cm) {
2907         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2908         grdev_session *session = cm->card.base.session;
2909         int r;
2910
2911         /*
2912          * If TakeDevice() is pending or was successful, make sure to
2913          * release the device again. We don't care for return-values,
2914          * so send it without waiting or callbacks.
2915          * If a failed TakeDevice() is pending, but someone else took
2916          * the device on the same bus-connection, we might incorrectly
2917          * release their device. This is an unlikely race, though.
2918          * Furthermore, you really shouldn't have two users of the
2919          * controller-API on the same session, on the same devices, *AND* on
2920          * the same bus-connection. So we don't care for that race..
2921          */
2922
2923         grdrm_card_close(&cm->card);
2924         cm->requested = false;
2925
2926         if (!cm->acquired && !cm->slot_take_device)
2927                 return;
2928
2929         cm->slot_take_device = sd_bus_slot_unref(cm->slot_take_device);
2930         cm->acquired = false;
2931
2932         r = sd_bus_message_new_method_call(session->context->sysbus,
2933                                            &m,
2934                                            "org.freedesktop.login1",
2935                                            session->path,
2936                                            "org.freedesktop.login1.Session",
2937                                            "ReleaseDevice");
2938         if (r >= 0) {
2939                 r = sd_bus_message_append(m, "uu", major(cm->devnum), minor(cm->devnum));
2940                 if (r >= 0)
2941                         r = sd_bus_send(session->context->sysbus, m, NULL);
2942         }
2943
2944         if (r < 0 && r != -ENOTCONN)
2945                 log_debug("grdrm: %s/%s: cannot send ReleaseDevice: %s",
2946                           session->name, cm->card.base.name, strerror(-r));
2947 }
2948
2949 static int managed_card_new(grdev_card **out, grdev_session *session, struct udev_device *ud) {
2950         _cleanup_(grdev_card_freep) grdev_card *basecard = NULL;
2951         char name[GRDRM_CARD_NAME_MAX];
2952         managed_card *cm;
2953         dev_t devnum;
2954         int r;
2955
2956         assert_return(session, -EINVAL);
2957         assert_return(session->managed, -EINVAL);
2958         assert_return(session->context->sysbus, -EINVAL);
2959         assert_return(ud, -EINVAL);
2960
2961         devnum = udev_device_get_devnum(ud);
2962         if (devnum == 0)
2963                 return -ENODEV;
2964
2965         grdrm_name(name, devnum);
2966
2967         cm = new0(managed_card, 1);
2968         if (!cm)
2969                 return -ENOMEM;
2970
2971         basecard = &cm->card.base;
2972         cm->card = GRDRM_CARD_INIT(&managed_card_vtable, session);
2973         cm->devnum = devnum;
2974
2975         r = managed_card_setup_bus(cm);
2976         if (r < 0)
2977                 return r;
2978
2979         r = grdrm_card_add(&cm->card, name);
2980         if (r < 0)
2981                 return r;
2982
2983         managed_card_take_device(cm);
2984
2985         if (out)
2986                 *out = basecard;
2987         basecard = NULL;
2988         return 0;
2989 }
2990
2991 static void managed_card_free(grdev_card *basecard) {
2992         managed_card *cm = managed_card_from_base(basecard);
2993
2994         assert(!basecard->enabled);
2995
2996         managed_card_release_device(cm);
2997         cm->slot_resume_device = sd_bus_slot_unref(cm->slot_resume_device);
2998         cm->slot_pause_device = sd_bus_slot_unref(cm->slot_pause_device);
2999         grdrm_card_destroy(&cm->card);
3000         free(cm);
3001 }
3002
3003 static const grdev_card_vtable managed_card_vtable = {
3004         .free                   = managed_card_free,
3005         .enable                 = managed_card_enable,
3006         .disable                = managed_card_disable,
3007         .commit                 = grdrm_card_commit,
3008         .restore                = grdrm_card_restore,
3009 };
3010
3011 /*
3012  * Generic Constructor
3013  * Instead of relying on the caller to choose between managed and unmanaged
3014  * DRM devices, the grdev_drm_new() constructor does that for you (by
3015  * looking at session->managed).
3016  */
3017
3018 bool grdev_is_drm_card(grdev_card *basecard) {
3019         return basecard && (basecard->vtable == &unmanaged_card_vtable ||
3020                             basecard->vtable == &managed_card_vtable);
3021 }
3022
3023 grdev_card *grdev_find_drm_card(grdev_session *session, dev_t devnum) {
3024         char name[GRDRM_CARD_NAME_MAX];
3025
3026         assert_return(session, NULL);
3027         assert_return(devnum != 0, NULL);
3028
3029         grdrm_name(name, devnum);
3030         return grdev_find_card(session, name);
3031 }
3032
3033 int grdev_drm_card_new(grdev_card **out, grdev_session *session, struct udev_device *ud) {
3034         assert_return(session, -EINVAL);
3035         assert_return(ud, -EINVAL);
3036
3037         return session->managed ? managed_card_new(out, session, ud) : unmanaged_card_new(out, session, ud);
3038 }
3039
3040 void grdev_drm_card_hotplug(grdev_card *basecard, struct udev_device *ud) {
3041         const char *p, *action;
3042         grdrm_card *card;
3043         dev_t devnum;
3044
3045         assert(basecard);
3046         assert(grdev_is_drm_card(basecard));
3047         assert(ud);
3048
3049         card = grdrm_card_from_base(basecard);
3050
3051         action = udev_device_get_action(ud);
3052         if (!action || streq(action, "add") || streq(action, "remove")) {
3053                 /* If we get add/remove events on DRM nodes without devnum, we
3054                  * got hotplugged DRM objects so refresh the device. */
3055                 devnum = udev_device_get_devnum(ud);
3056                 if (devnum == 0) {
3057                         card->hotplug = true;
3058                         grdrm_card_hotplug(card);
3059                 }
3060         } else if (streq_ptr(action, "change")) {
3061                 /* A change event with HOTPLUG=1 is sent whenever a connector
3062                  * changed state. Refresh the device to update our state. */
3063                 p = udev_device_get_property_value(ud, "HOTPLUG");
3064                 if (streq_ptr(p, "1")) {
3065                         card->hotplug = true;
3066                         grdrm_card_hotplug(card);
3067                 }
3068         }
3069 }