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 **slot) {
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 = fb_from_base(*slot);
1103         size_t i;
1104         int r;
1105
1106         assert(crtc);
1107         assert(slot);
1108         assert(*slot);
1109         assert(pipe);
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         *slot = 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         if (!pipe->base.back) {
1149                 for (i = 0; i < pipe->base.max_fbs; ++i) {
1150                         if (!pipe->base.fbs[i])
1151                                 continue;
1152
1153                         fb = fb_from_base(pipe->base.fbs[i]);
1154                         if (&fb->base == pipe->base.front)
1155                                 continue;
1156
1157                         fb->flipid = 0;
1158                         pipe->base.back = &fb->base;
1159                         break;
1160                 }
1161         }
1162 }
1163
1164 static int grdrm_crtc_commit_flip(grdrm_crtc *crtc, grdev_fb **slot) {
1165         struct drm_mode_crtc_page_flip page_flip = { .crtc_id = crtc->object.id };
1166         grdrm_card *card = crtc->object.card;
1167         grdrm_pipe *pipe = crtc->pipe;
1168         grdrm_fb *fb = fb_from_base(*slot);
1169         uint32_t cnt;
1170         size_t i;
1171         int r;
1172
1173         assert(crtc);
1174         assert(slot);
1175         assert(*slot);
1176         assert(pipe);
1177
1178         if (!crtc->applied && !grdrm_modes_compatible(&crtc->kern.mode, &crtc->set.mode))
1179                 return 0;
1180
1181         cnt = ++pipe->counter ? : ++pipe->counter;
1182         page_flip.fb_id = fb->id;
1183         page_flip.flags = DRM_MODE_PAGE_FLIP_EVENT;
1184         page_flip.user_data = grdrm_encode_vblank_data(crtc->object.id, cnt);
1185
1186         r = ioctl(card->fd, DRM_IOCTL_MODE_PAGE_FLIP, &page_flip);
1187         if (r < 0) {
1188                 r = -errno;
1189                 /* Avoid excessive logging on EINVAL; it is currently not
1190                  * possible to see whether cards support page-flipping, so
1191                  * avoid logging on each frame. */
1192                 if (r != -EINVAL)
1193                         log_debug("grdrm: %s: cannot schedule page-flip on crtc %" PRIu32 ": %m",
1194                                   card->base.name, crtc->object.id);
1195
1196                 if (grdrm_card_async(card, r))
1197                         return r;
1198
1199                 return 0;
1200         }
1201
1202         if (!crtc->applied) {
1203                 log_debug("grdrm: %s: crtc %" PRIu32 " applied via page flip",
1204                           card->base.name, crtc->object.id);
1205                 crtc->applied = true;
1206         }
1207
1208         pipe->base.flipping = true;
1209         pipe->base.flip = false;
1210         pipe->counter = cnt;
1211         fb->flipid = cnt;
1212         *slot = NULL;
1213
1214         /* Raise fake FRAME event if it takes longer than 2
1215          * frames to receive the pageflip event. We assume the
1216          * queue ran over or some other error happened. */
1217         grdev_pipe_schedule(&pipe->base, 2);
1218
1219         if (!pipe->base.back) {
1220                 for (i = 0; i < pipe->base.max_fbs; ++i) {
1221                         if (!pipe->base.fbs[i])
1222                                 continue;
1223
1224                         fb = fb_from_base(pipe->base.fbs[i]);
1225                         if (&fb->base == pipe->base.front)
1226                                 continue;
1227                         if (fb->flipid)
1228                                 continue;
1229
1230                         pipe->base.back = &fb->base;
1231                         break;
1232                 }
1233         }
1234
1235         return 1;
1236 }
1237
1238 static void grdrm_crtc_commit(grdrm_crtc *crtc) {
1239         struct drm_mode_crtc set_crtc = { .crtc_id = crtc->object.id };
1240         grdrm_card *card = crtc->object.card;
1241         grdrm_pipe *pipe;
1242         grdev_fb **slot;
1243         int r;
1244
1245         assert(crtc);
1246         assert(crtc->object.assigned);
1247
1248         pipe = crtc->pipe;
1249         if (!pipe) {
1250                 /* If a crtc is not assigned any connector, we want any
1251                  * previous setup to be cleared, so make sure the CRTC is
1252                  * disabled. Otherwise, there might be content on the CRTC
1253                  * while we run, which is not what we want.
1254                  * If you want to avoid modesets on specific CRTCs, you should
1255                  * still keep their assignment, but never enable the resulting
1256                  * pipe. This way, we wouldn't touch it at all. */
1257                 if (!crtc->applied) {
1258                         crtc->applied = true;
1259                         r = ioctl(card->fd, DRM_IOCTL_MODE_SETCRTC, &set_crtc);
1260                         if (r < 0) {
1261                                 r = -errno;
1262                                 log_debug("grdrm: %s: cannot shutdown crtc %" PRIu32 ": %m",
1263                                           card->base.name, crtc->object.id);
1264
1265                                 grdrm_card_async(card, r);
1266                                 return;
1267                         }
1268
1269                         log_debug("grdrm: %s: crtc %" PRIu32 " applied via shutdown",
1270                                   card->base.name, crtc->object.id);
1271                 }
1272
1273                 return;
1274         }
1275
1276         /* we always fully ignore disabled pipes */
1277         if (!pipe->base.enabled)
1278                 return;
1279
1280         assert(crtc->set.n_connectors > 0);
1281
1282         if (pipe->base.flip)
1283                 slot = &pipe->base.back;
1284         else if (!crtc->applied)
1285                 slot = &pipe->base.front;
1286         else
1287                 return;
1288
1289         if (!*slot)
1290                 return;
1291
1292         r = grdrm_crtc_commit_flip(crtc, slot);
1293         if (r == 0) {
1294                 /* in case we couldn't page-flip, perform deep modeset */
1295                 grdrm_crtc_commit_deep(crtc, slot);
1296         }
1297 }
1298
1299 static void grdrm_crtc_restore(grdrm_crtc *crtc) {
1300         struct drm_mode_crtc set_crtc = { .crtc_id = crtc->object.id };
1301         grdrm_card *card = crtc->object.card;
1302         int r;
1303
1304         if (!crtc->old.set)
1305                 return;
1306
1307         set_crtc.set_connectors_ptr = PTR_TO_UINT64(crtc->old.connectors);
1308         set_crtc.count_connectors = crtc->old.n_connectors;
1309         set_crtc.fb_id = crtc->old.fb;
1310         set_crtc.x = crtc->old.fb_x;
1311         set_crtc.y = crtc->old.fb_y;
1312         set_crtc.gamma_size = crtc->old.gamma;
1313         set_crtc.mode_valid = crtc->old.mode_set;
1314         set_crtc.mode = crtc->old.mode;
1315
1316         r = ioctl(card->fd, DRM_IOCTL_MODE_SETCRTC, &set_crtc);
1317         if (r < 0) {
1318                 r = -errno;
1319                 log_debug("grdrm: %s: cannot restore crtc %" PRIu32 ": %m",
1320                           card->base.name, crtc->object.id);
1321
1322                 grdrm_card_async(card, r);
1323                 return;
1324         }
1325
1326         if (crtc->pipe) {
1327                 ++crtc->pipe->counter;
1328                 crtc->pipe->base.front = NULL;
1329                 crtc->pipe->base.flipping = false;
1330         }
1331
1332         log_debug("grdrm: %s: crtc %" PRIu32 " restored", card->base.name, crtc->object.id);
1333 }
1334
1335 static void grdrm_crtc_flip_complete(grdrm_crtc *crtc, uint32_t counter, struct drm_event_vblank *event) {
1336         bool flipped = false;
1337         grdrm_pipe *pipe;
1338         grdrm_fb *back = NULL;
1339         size_t i;
1340
1341         assert(crtc);
1342         assert(event);
1343
1344         pipe = crtc->pipe;
1345         if (!pipe)
1346                 return;
1347
1348         /* We got a page-flip event. To be safe, we reset all FBs on the same
1349          * pipe that have smaller flipids than the flip we got as we know they
1350          * are executed in order. We need to do this to guarantee
1351          * queue-overflows or other missed events don't cause starvation.
1352          * Furthermore, if we find the exact FB this event is for, *and* this
1353          * is the most recent event, we mark it as front FB and raise a
1354          * frame event. */
1355
1356         for (i = 0; i < pipe->base.max_fbs; ++i) {
1357                 grdrm_fb *fb;
1358
1359                 if (!pipe->base.fbs[i])
1360                         continue;
1361
1362                 fb = fb_from_base(pipe->base.fbs[i]);
1363                 if (counter != 0 && counter == pipe->counter && fb->flipid == counter) {
1364                         pipe->base.front = &fb->base;
1365                         flipped = true;
1366                 }
1367
1368                 if (counter - fb->flipid < UINT16_MAX) {
1369                         fb->flipid = 0;
1370                         back = fb;
1371                 } else if (fb->flipid == 0) {
1372                         back = fb;
1373                 }
1374         }
1375
1376         if (!pipe->base.back)
1377                 pipe->base.back = &back->base;
1378
1379         if (flipped) {
1380                 crtc->pipe->base.flipping = false;
1381                 grdev_pipe_frame(&pipe->base);
1382         }
1383 }
1384
1385 /*
1386  * Framebuffers
1387  */
1388
1389 static int grdrm_fb_new(grdrm_fb **out, grdrm_card *card, const struct drm_mode_modeinfo *mode) {
1390         _cleanup_(grdrm_fb_freep) grdrm_fb *fb = NULL;
1391         struct drm_mode_create_dumb create_dumb = { };
1392         struct drm_mode_map_dumb map_dumb = { };
1393         struct drm_mode_fb_cmd2 add_fb = { };
1394         unsigned int i;
1395         int r;
1396
1397         assert_return(out, -EINVAL);
1398         assert_return(card, -EINVAL);
1399
1400         fb = new0(grdrm_fb, 1);
1401         if (!fb)
1402                 return -ENOMEM;
1403
1404         /* TODO: we should choose a compatible format of the previous CRTC
1405          * setting to allow page-flip to it. Only choose fallback if the
1406          * previous setting was crap (non xrgb32'ish). */
1407
1408         fb->card = card;
1409         fb->base.format = DRM_FORMAT_XRGB8888;
1410         fb->base.width = mode->hdisplay;
1411         fb->base.height = mode->vdisplay;
1412
1413         for (i = 0; i < ELEMENTSOF(fb->base.maps); ++i)
1414                 fb->base.maps[i] = MAP_FAILED;
1415
1416         create_dumb.width = fb->base.width;
1417         create_dumb.height = fb->base.height;
1418         create_dumb.bpp = 32;
1419
1420         r = ioctl(card->fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_dumb);
1421         if (r < 0) {
1422                 r = -errno;
1423                 log_debug("grdrm: %s: cannot create dumb buffer %" PRIu32 "x%" PRIu32": %m",
1424                           card->base.name, fb->base.width, fb->base.height);
1425                 return r;
1426         }
1427
1428         fb->handles[0] = create_dumb.handle;
1429         fb->base.strides[0] = create_dumb.pitch;
1430         fb->sizes[0] = create_dumb.size;
1431
1432         map_dumb.handle = fb->handles[0];
1433
1434         r = ioctl(card->fd, DRM_IOCTL_MODE_MAP_DUMB, &map_dumb);
1435         if (r < 0) {
1436                 r = -errno;
1437                 log_debug("grdrm: %s: cannot map dumb buffer %" PRIu32 "x%" PRIu32": %m",
1438                           card->base.name, fb->base.width, fb->base.height);
1439                 return r;
1440         }
1441
1442         fb->base.maps[0] = mmap(0, fb->sizes[0], PROT_WRITE, MAP_SHARED, card->fd, map_dumb.offset);
1443         if (fb->base.maps[0] == MAP_FAILED) {
1444                 r = -errno;
1445                 log_debug("grdrm: %s: cannot memory-map dumb buffer %" PRIu32 "x%" PRIu32": %m",
1446                           card->base.name, fb->base.width, fb->base.height);
1447                 return r;
1448         }
1449
1450         memzero(fb->base.maps[0], fb->sizes[0]);
1451
1452         add_fb.width = fb->base.width;
1453         add_fb.height = fb->base.height;
1454         add_fb.pixel_format = fb->base.format;
1455         add_fb.flags = 0;
1456         memcpy(add_fb.handles, fb->handles, sizeof(fb->handles));
1457         memcpy(add_fb.pitches, fb->base.strides, sizeof(fb->base.strides));
1458         memcpy(add_fb.offsets, fb->offsets, sizeof(fb->offsets));
1459
1460         r = ioctl(card->fd, DRM_IOCTL_MODE_ADDFB2, &add_fb);
1461         if (r < 0) {
1462                 r = -errno;
1463                 log_debug("grdrm: %s: cannot add framebuffer %" PRIu32 "x%" PRIu32": %m",
1464                           card->base.name, fb->base.width, fb->base.height);
1465                 return r;
1466         }
1467
1468         fb->id = add_fb.fb_id;
1469
1470         *out = fb;
1471         fb = NULL;
1472         return 0;
1473 }
1474
1475 grdrm_fb *grdrm_fb_free(grdrm_fb *fb) {
1476         unsigned int i;
1477         int r;
1478
1479         if (!fb)
1480                 return NULL;
1481
1482         assert(fb->card);
1483
1484         if (fb->id > 0 && fb->card->fd >= 0) {
1485                 r = ioctl(fb->card->fd, DRM_IOCTL_MODE_RMFB, fb->id);
1486                 if (r < 0)
1487                         log_debug("grdrm: %s: cannot delete framebuffer %" PRIu32 ": %m",
1488                                   fb->card->base.name, fb->id);
1489         }
1490
1491         for (i = 0; i < ELEMENTSOF(fb->handles); ++i) {
1492                 struct drm_mode_destroy_dumb destroy_dumb = { };
1493
1494                 if (fb->base.maps[i] != MAP_FAILED)
1495                         munmap(fb->base.maps[i], fb->sizes[i]);
1496
1497                 if (fb->handles[i] > 0 && fb->card->fd >= 0) {
1498                         destroy_dumb.handle = fb->handles[i];
1499                         r = ioctl(fb->card->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_dumb);
1500                         if (r < 0)
1501                                 log_debug("grdrm: %s: cannot destroy dumb-buffer %" PRIu32 ": %m",
1502                                           fb->card->base.name, fb->handles[i]);
1503                 }
1504         }
1505
1506         free(fb);
1507
1508         return NULL;
1509 }
1510
1511 /*
1512  * Pipes
1513  */
1514
1515 static void grdrm_pipe_name(char *out, grdrm_crtc *crtc) {
1516         /* @out must be at least of size GRDRM_PIPE_NAME_MAX */
1517         sprintf(out, "%s/%" PRIu32, crtc->object.card->base.name, crtc->object.id);
1518 }
1519
1520 static int grdrm_pipe_new(grdrm_pipe **out, grdrm_crtc *crtc, struct drm_mode_modeinfo *mode, size_t n_fbs) {
1521         _cleanup_(grdev_pipe_freep) grdev_pipe *basepipe = NULL;
1522         grdrm_card *card = crtc->object.card;
1523         char name[GRDRM_PIPE_NAME_MAX];
1524         grdrm_pipe *pipe;
1525         int r;
1526
1527         assert_return(crtc, -EINVAL);
1528         assert_return(grdev_is_drm_card(&card->base), -EINVAL);
1529
1530         pipe = new0(grdrm_pipe, 1);
1531         if (!pipe)
1532                 return -ENOMEM;
1533
1534         basepipe = &pipe->base;
1535         pipe->base = GRDEV_PIPE_INIT(&grdrm_pipe_vtable, &card->base);
1536         pipe->crtc = crtc;
1537         pipe->base.width = mode->hdisplay;
1538         pipe->base.height = mode->vdisplay;
1539         pipe->base.vrefresh = mode->vrefresh ? : 25;
1540
1541         grdrm_pipe_name(name, crtc);
1542         r = grdev_pipe_add(&pipe->base, name, n_fbs);
1543         if (r < 0)
1544                 return r;
1545
1546         if (out)
1547                 *out = pipe;
1548         basepipe = NULL;
1549         return 0;
1550 }
1551
1552 static void grdrm_pipe_free(grdev_pipe *basepipe) {
1553         grdrm_pipe *pipe = grdrm_pipe_from_base(basepipe);
1554         size_t i;
1555
1556         assert(pipe->crtc);
1557
1558         for (i = 0; i < pipe->base.max_fbs; ++i)
1559                 if (pipe->base.fbs[i])
1560                         grdrm_fb_free(fb_from_base(pipe->base.fbs[i]));
1561
1562         free(pipe);
1563 }
1564
1565 static const grdev_pipe_vtable grdrm_pipe_vtable = {
1566         .free                   = grdrm_pipe_free,
1567 };
1568
1569 /*
1570  * Cards
1571  */
1572
1573 static void grdrm_name(char *out, dev_t devnum) {
1574         /* @out must be at least of size GRDRM_CARD_NAME_MAX */
1575         sprintf(out, "drm/%u:%u", major(devnum), minor(devnum));
1576 }
1577
1578 static void grdrm_card_print(grdrm_card *card) {
1579         grdrm_object *object;
1580         grdrm_crtc *crtc;
1581         grdrm_encoder *encoder;
1582         grdrm_connector *connector;
1583         grdrm_plane *plane;
1584         Iterator iter;
1585         uint32_t i;
1586         char *p, *buf;
1587
1588         log_debug("grdrm: %s: state dump", card->base.name);
1589
1590         log_debug("  crtcs:");
1591         HASHMAP_FOREACH(object, card->object_map, iter) {
1592                 if (object->type != GRDRM_TYPE_CRTC)
1593                         continue;
1594
1595                 crtc = crtc_from_object(object);
1596                 log_debug("    (id: %u index: %d)", object->id, object->index);
1597
1598                 if (crtc->kern.mode_set)
1599                         log_debug("      mode: %dx%d", crtc->kern.mode.hdisplay, crtc->kern.mode.vdisplay);
1600                 else
1601                         log_debug("      mode: <none>");
1602         }
1603
1604         log_debug("  encoders:");
1605         HASHMAP_FOREACH(object, card->object_map, iter) {
1606                 if (object->type != GRDRM_TYPE_ENCODER)
1607                         continue;
1608
1609                 encoder = encoder_from_object(object);
1610                 log_debug("    (id: %u index: %d)", object->id, object->index);
1611
1612                 if (encoder->kern.used_crtc)
1613                         log_debug("      crtc: %u", encoder->kern.used_crtc);
1614                 else
1615                         log_debug("      crtc: <none>");
1616
1617                 buf = malloc((DECIMAL_STR_MAX(uint32_t) + 1) * encoder->kern.n_crtcs + 1);
1618                 if (buf) {
1619                         buf[0] = 0;
1620                         p = buf;
1621
1622                         for (i = 0; i < encoder->kern.n_crtcs; ++i)
1623                                 p += sprintf(p, " %" PRIu32, encoder->kern.crtcs[i]);
1624
1625                         log_debug("      possible crtcs:%s", buf);
1626                         free(buf);
1627                 }
1628
1629                 buf = malloc((DECIMAL_STR_MAX(uint32_t) + 1) * encoder->kern.n_clones + 1);
1630                 if (buf) {
1631                         buf[0] = 0;
1632                         p = buf;
1633
1634                         for (i = 0; i < encoder->kern.n_clones; ++i)
1635                                 p += sprintf(p, " %" PRIu32, encoder->kern.clones[i]);
1636
1637                         log_debug("      possible clones:%s", buf);
1638                         free(buf);
1639                 }
1640         }
1641
1642         log_debug("  connectors:");
1643         HASHMAP_FOREACH(object, card->object_map, iter) {
1644                 if (object->type != GRDRM_TYPE_CONNECTOR)
1645                         continue;
1646
1647                 connector = connector_from_object(object);
1648                 log_debug("    (id: %u index: %d)", object->id, object->index);
1649                 log_debug("      type: %" PRIu32 "-%" PRIu32 " connection: %" PRIu32 " subpixel: %" PRIu32 " extents: %" PRIu32 "x%" PRIu32,
1650                           connector->kern.type, connector->kern.type_id, connector->kern.connection, connector->kern.subpixel,
1651                           connector->kern.mm_width, connector->kern.mm_height);
1652
1653                 if (connector->kern.used_encoder)
1654                         log_debug("      encoder: %" PRIu32, connector->kern.used_encoder);
1655                 else
1656                         log_debug("      encoder: <none>");
1657
1658                 buf = malloc((DECIMAL_STR_MAX(uint32_t) + 1) * connector->kern.n_encoders + 1);
1659                 if (buf) {
1660                         buf[0] = 0;
1661                         p = buf;
1662
1663                         for (i = 0; i < connector->kern.n_encoders; ++i)
1664                                 p += sprintf(p, " %" PRIu32, connector->kern.encoders[i]);
1665
1666                         log_debug("      possible encoders:%s", buf);
1667                         free(buf);
1668                 }
1669
1670                 for (i = 0; i < connector->kern.n_modes; ++i) {
1671                         struct drm_mode_modeinfo *mode = &connector->kern.modes[i];
1672                         log_debug("      mode: %" PRIu32 "x%" PRIu32, mode->hdisplay, mode->vdisplay);
1673                 }
1674         }
1675
1676         log_debug("  planes:");
1677         HASHMAP_FOREACH(object, card->object_map, iter) {
1678                 if (object->type != GRDRM_TYPE_PLANE)
1679                         continue;
1680
1681                 plane = plane_from_object(object);
1682                 log_debug("    (id: %u index: %d)", object->id, object->index);
1683                 log_debug("      gamma-size: %" PRIu32, plane->kern.gamma_size);
1684
1685                 if (plane->kern.used_crtc)
1686                         log_debug("      crtc: %" PRIu32, plane->kern.used_crtc);
1687                 else
1688                         log_debug("      crtc: <none>");
1689
1690                 buf = malloc((DECIMAL_STR_MAX(uint32_t) + 1) * plane->kern.n_crtcs + 1);
1691                 if (buf) {
1692                         buf[0] = 0;
1693                         p = buf;
1694
1695                         for (i = 0; i < plane->kern.n_crtcs; ++i)
1696                                 p += sprintf(p, " %" PRIu32, plane->kern.crtcs[i]);
1697
1698                         log_debug("      possible crtcs:%s", buf);
1699                         free(buf);
1700                 }
1701
1702                 buf = malloc((DECIMAL_STR_MAX(unsigned int) + 3) * plane->kern.n_formats + 1);
1703                 if (buf) {
1704                         buf[0] = 0;
1705                         p = buf;
1706
1707                         for (i = 0; i < plane->kern.n_formats; ++i)
1708                                 p += sprintf(p, " 0x%x", (unsigned int)plane->kern.formats[i]);
1709
1710                         log_debug("      possible formats:%s", buf);
1711                         free(buf);
1712                 }
1713         }
1714 }
1715
1716 static int grdrm_card_resync(grdrm_card *card) {
1717         _cleanup_free_ uint32_t *crtc_ids = NULL, *encoder_ids = NULL, *connector_ids = NULL, *plane_ids = NULL;
1718         uint32_t allocated = 0;
1719         grdrm_object *object;
1720         Iterator iter;
1721         size_t tries;
1722         int r;
1723
1724         assert(card);
1725
1726         card->async_hotplug = false;
1727         allocated = 0;
1728
1729         /* mark existing objects for possible removal */
1730         HASHMAP_FOREACH(object, card->object_map, iter)
1731                 object->present = false;
1732
1733         for (tries = 0; tries < GRDRM_MAX_TRIES; ++tries) {
1734                 struct drm_mode_get_plane_res pres;
1735                 struct drm_mode_card_res res;
1736                 uint32_t i, max;
1737
1738                 if (allocated < card->max_ids) {
1739                         free(crtc_ids);
1740                         free(encoder_ids);
1741                         free(connector_ids);
1742                         free(plane_ids);
1743                         crtc_ids = new0(uint32_t, card->max_ids);
1744                         encoder_ids = new0(uint32_t, card->max_ids);
1745                         connector_ids = new0(uint32_t, card->max_ids);
1746                         plane_ids = new0(uint32_t, card->max_ids);
1747
1748                         if (!crtc_ids || !encoder_ids || !connector_ids || !plane_ids)
1749                                 return -ENOMEM;
1750
1751                         allocated = card->max_ids;
1752                 }
1753
1754                 zero(res);
1755                 res.crtc_id_ptr = PTR_TO_UINT64(crtc_ids);
1756                 res.connector_id_ptr = PTR_TO_UINT64(connector_ids);
1757                 res.encoder_id_ptr = PTR_TO_UINT64(encoder_ids);
1758                 res.count_crtcs = allocated;
1759                 res.count_encoders = allocated;
1760                 res.count_connectors = allocated;
1761
1762                 r = ioctl(card->fd, DRM_IOCTL_MODE_GETRESOURCES, &res);
1763                 if (r < 0) {
1764                         r = -errno;
1765                         log_debug("grdrm: %s: cannot retrieve drm resources: %m", card->base.name);
1766                         return r;
1767                 }
1768
1769                 zero(pres);
1770                 pres.plane_id_ptr = PTR_TO_UINT64(plane_ids);
1771                 pres.count_planes = allocated;
1772
1773                 r = ioctl(card->fd, DRM_IOCTL_MODE_GETPLANERESOURCES, &pres);
1774                 if (r < 0) {
1775                         r = -errno;
1776                         log_debug("grdrm: %s: cannot retrieve drm plane-resources: %m", card->base.name);
1777                         return r;
1778                 }
1779
1780                 max = MAX(MAX(res.count_crtcs, res.count_encoders),
1781                           MAX(res.count_connectors, pres.count_planes));
1782                 if (max > allocated) {
1783                         uint32_t n;
1784
1785                         n = ALIGN_POWER2(max);
1786                         if (!n || n > UINT16_MAX) {
1787                                 log_debug("grdrm: %s: excessive DRM resource limit: %" PRIu32, card->base.name, max);
1788                                 return -ERANGE;
1789                         }
1790
1791                         /* retry with resized buffers */
1792                         card->max_ids = n;
1793                         continue;
1794                 }
1795
1796                 /* mark available objects as present */
1797
1798                 for (i = 0; i < res.count_crtcs; ++i) {
1799                         object = grdrm_find_object(card, crtc_ids[i]);
1800                         if (object && object->type == GRDRM_TYPE_CRTC) {
1801                                 object->present = true;
1802                                 object->index = i;
1803                                 crtc_ids[i] = 0;
1804                         }
1805                 }
1806
1807                 for (i = 0; i < res.count_encoders; ++i) {
1808                         object = grdrm_find_object(card, encoder_ids[i]);
1809                         if (object && object->type == GRDRM_TYPE_ENCODER) {
1810                                 object->present = true;
1811                                 object->index = i;
1812                                 encoder_ids[i] = 0;
1813                         }
1814                 }
1815
1816                 for (i = 0; i < res.count_connectors; ++i) {
1817                         object = grdrm_find_object(card, connector_ids[i]);
1818                         if (object && object->type == GRDRM_TYPE_CONNECTOR) {
1819                                 object->present = true;
1820                                 object->index = i;
1821                                 connector_ids[i] = 0;
1822                         }
1823                 }
1824
1825                 for (i = 0; i < pres.count_planes; ++i) {
1826                         object = grdrm_find_object(card, plane_ids[i]);
1827                         if (object && object->type == GRDRM_TYPE_PLANE) {
1828                                 object->present = true;
1829                                 object->index = i;
1830                                 plane_ids[i] = 0;
1831                         }
1832                 }
1833
1834                 /* drop removed objects */
1835
1836                 HASHMAP_FOREACH(object, card->object_map, iter)
1837                         if (!object->present)
1838                                 grdrm_object_free(object);
1839
1840                 /* add new objects */
1841
1842                 card->n_crtcs = res.count_crtcs;
1843                 for (i = 0; i < res.count_crtcs; ++i) {
1844                         if (crtc_ids[i] < 1)
1845                                 continue;
1846
1847                         r = grdrm_crtc_new(NULL, card, crtc_ids[i], i);
1848                         if (r < 0)
1849                                 return r;
1850                 }
1851
1852                 card->n_encoders = res.count_encoders;
1853                 for (i = 0; i < res.count_encoders; ++i) {
1854                         if (encoder_ids[i] < 1)
1855                                 continue;
1856
1857                         r = grdrm_encoder_new(NULL, card, encoder_ids[i], i);
1858                         if (r < 0)
1859                                 return r;
1860                 }
1861
1862                 card->n_connectors = res.count_connectors;
1863                 for (i = 0; i < res.count_connectors; ++i) {
1864                         if (connector_ids[i] < 1)
1865                                 continue;
1866
1867                         r = grdrm_connector_new(NULL, card, connector_ids[i], i);
1868                         if (r < 0)
1869                                 return r;
1870                 }
1871
1872                 card->n_planes = pres.count_planes;
1873                 for (i = 0; i < pres.count_planes; ++i) {
1874                         if (plane_ids[i] < 1)
1875                                 continue;
1876
1877                         r = grdrm_plane_new(NULL, card, plane_ids[i], i);
1878                         if (r < 0)
1879                                 return r;
1880                 }
1881
1882                 /* re-sync objects after object_map is synced */
1883
1884                 HASHMAP_FOREACH(object, card->object_map, iter) {
1885                         switch (object->type) {
1886                         case GRDRM_TYPE_CRTC:
1887                                 r = grdrm_crtc_resync(crtc_from_object(object));
1888                                 break;
1889                         case GRDRM_TYPE_ENCODER:
1890                                 r = grdrm_encoder_resync(encoder_from_object(object));
1891                                 break;
1892                         case GRDRM_TYPE_CONNECTOR:
1893                                 r = grdrm_connector_resync(connector_from_object(object));
1894                                 break;
1895                         case GRDRM_TYPE_PLANE:
1896                                 r = grdrm_plane_resync(plane_from_object(object));
1897                                 break;
1898                         default:
1899                                 assert_not_reached("grdrm: invalid object type");
1900                                 r = 0;
1901                         }
1902
1903                         if (r < 0)
1904                                 return r;
1905
1906                         if (card->async_hotplug)
1907                                 break;
1908                 }
1909
1910                 /* if modeset objects change during sync, start over */
1911                 if (card->async_hotplug) {
1912                         card->async_hotplug = false;
1913                         continue;
1914                 }
1915
1916                 /* cache crtc/connector relationship */
1917                 HASHMAP_FOREACH(object, card->object_map, iter) {
1918                         grdrm_connector *connector;
1919                         grdrm_encoder *encoder;
1920                         grdrm_crtc *crtc;
1921
1922                         if (object->type != GRDRM_TYPE_CONNECTOR)
1923                                 continue;
1924
1925                         connector = connector_from_object(object);
1926                         if (connector->kern.connection != 1 || connector->kern.used_encoder < 1)
1927                                 continue;
1928
1929                         object = grdrm_find_object(card, connector->kern.used_encoder);
1930                         if (!object || object->type != GRDRM_TYPE_ENCODER)
1931                                 continue;
1932
1933                         encoder = encoder_from_object(object);
1934                         if (encoder->kern.used_crtc < 1)
1935                                 continue;
1936
1937                         object = grdrm_find_object(card, encoder->kern.used_crtc);
1938                         if (!object || object->type != GRDRM_TYPE_CRTC)
1939                                 continue;
1940
1941                         crtc = crtc_from_object(object);
1942                         assert(crtc->kern.n_used_connectors < crtc->kern.max_used_connectors);
1943                         crtc->kern.used_connectors[crtc->kern.n_used_connectors++] = connector->object.id;
1944                 }
1945
1946                 /* cache old crtc settings for later restore */
1947                 HASHMAP_FOREACH(object, card->object_map, iter) {
1948                         grdrm_crtc *crtc;
1949
1950                         if (object->type != GRDRM_TYPE_CRTC)
1951                                 continue;
1952
1953                         crtc = crtc_from_object(object);
1954
1955                         /* Save data if it is the first time we refresh the CRTC. This data can
1956                          * be used optionally to restore any previous configuration. For
1957                          * instance, it allows us to restore VT configurations after we close
1958                          * our session again. */
1959                         if (!crtc->old.set) {
1960                                 crtc->old.fb = crtc->kern.used_fb;
1961                                 crtc->old.fb_x = crtc->kern.fb_offset_x;
1962                                 crtc->old.fb_y = crtc->kern.fb_offset_y;
1963                                 crtc->old.gamma = crtc->kern.gamma_size;
1964                                 crtc->old.n_connectors = crtc->kern.n_used_connectors;
1965                                 if (crtc->old.n_connectors)
1966                                         memcpy(crtc->old.connectors, crtc->kern.used_connectors, sizeof(uint32_t) * crtc->old.n_connectors);
1967                                 crtc->old.mode_set = crtc->kern.mode_set;
1968                                 crtc->old.mode = crtc->kern.mode;
1969                                 crtc->old.set = true;
1970                         }
1971                 }
1972
1973                 /* everything synced */
1974                 break;
1975         }
1976
1977         if (tries >= GRDRM_MAX_TRIES) {
1978                 /*
1979                  * Ugh! We were unable to sync the DRM card state due to heavy
1980                  * hotplugging. This should never happen, so print a debug
1981                  * message and bail out. The next uevent will trigger
1982                  * this again.
1983                  */
1984
1985                 log_debug("grdrm: %s: hotplug-storm when syncing card", card->base.name);
1986                 return -EFAULT;
1987         }
1988
1989         return 0;
1990 }
1991
1992 static bool card_configure_crtc(grdrm_crtc *crtc, grdrm_connector *connector) {
1993         grdrm_card *card = crtc->object.card;
1994         grdrm_encoder *encoder;
1995         grdrm_object *object;
1996         uint32_t i, j;
1997
1998         if (crtc->object.assigned || connector->object.assigned)
1999                 return false;
2000         if (connector->kern.connection != 1)
2001                 return false;
2002
2003         for (i = 0; i < connector->kern.n_encoders; ++i) {
2004                 object = grdrm_find_object(card, connector->kern.encoders[i]);
2005                 if (!object || object->type != GRDRM_TYPE_ENCODER)
2006                         continue;
2007
2008                 encoder = encoder_from_object(object);
2009                 for (j = 0; j < encoder->kern.n_crtcs; ++j) {
2010                         if (encoder->kern.crtcs[j] == crtc->object.id) {
2011                                 grdrm_crtc_assign(crtc, connector);
2012                                 return true;
2013                         }
2014                 }
2015         }
2016
2017         return false;
2018 }
2019
2020 static void grdrm_card_configure(grdrm_card *card) {
2021         /*
2022          * Modeset Configuration
2023          * This is where we update our modeset configuration and assign
2024          * connectors to CRTCs. This means, each connector that we want to
2025          * enable needs a CRTC, disabled (or unavailable) connectors are left
2026          * alone in the dark. Once all CRTCs are assigned, the remaining CRTCs
2027          * are disabled.
2028          * Sounds trivial, but there're several caveats:
2029          *
2030          *   * Multiple connectors can be driven by the same CRTC. This is
2031          *     known as 'hardware clone mode'. Advantage over software clone
2032          *     mode is that only a single CRTC is needed to drive multiple
2033          *     displays. However, few hardware supports this and it's a huge
2034          *     headache to configure on dynamic demands. Therefore, we only
2035          *     support it if configured statically beforehand.
2036          *
2037          *   * CRTCs are not created equal. Some might be much more poweful
2038          *     than others, including more advanced plane support. So far, our
2039          *     CRTC selection is random. You need to supply static
2040          *     configuration if you want special setups. So far, there is no
2041          *     proper way to do advanced CRTC selection on dynamic demands. It
2042          *     is not really clear which demands require what CRTC, so, like
2043          *     everyone else, we do random CRTC selection unless explicitly
2044          *     states otherwise.
2045          *
2046          *   * Each Connector has a list of possible encoders that can drive
2047          *     it, and each encoder has a list of possible CRTCs. If this graph
2048          *     is a tree, assignment is trivial. However, if not, we cannot
2049          *     reliably decide on configurations beforehand. The encoder is
2050          *     always selected by the kernel, so we have to actually set a mode
2051          *     to know which encoder is used. There is no way to ask the kernel
2052          *     whether a given configuration is possible. This will change with
2053          *     atomic-modesetting, but until then, we keep our configurations
2054          *     simple and assume they work all just fine. If one fails
2055          *     unexpectedly, we print a warning and disable it.
2056          *
2057          * Configuring a card consists of several steps:
2058          *
2059          *  1) First of all, we apply any user-configuration. If a user wants
2060          *     a fixed configuration, we apply it and preserve it.
2061          *     So far, we don't support user configuration files, so this step
2062          *     is skipped.
2063          *
2064          *  2) Secondly, we need to apply any quirks from hwdb. Some hardware
2065          *     might only support limited configurations or require special
2066          *     CRTC/Connector mappings. We read this from hwdb and apply it, if
2067          *     present.
2068          *     So far, we don't support this as there is no known quirk, so
2069          *     this step is skipped.
2070          *
2071          *  3) As deep modesets are expensive, we try to avoid them if
2072          *     possible. Therefore, we read the current configuration from the
2073          *     kernel and try to preserve it, if compatible with our demands.
2074          *     If not, we break it and reassign it in a following step.
2075          *
2076          *  4) The main step involves configuring all remaining objects. By
2077          *     default, all available connectors are enabled, except for those
2078          *     disabled by user-configuration. We lookup a suitable CRTC for
2079          *     each connector and assign them. As there might be more
2080          *     connectors than CRTCs, we apply some ordering so users can
2081          *     select which connectors are more important right now.
2082          *     So far, we only apply the default ordering, more might be added
2083          *     in the future.
2084          */
2085
2086         grdrm_object *object;
2087         grdrm_crtc *crtc;
2088         Iterator i, j;
2089
2090         /* clear assignments */
2091         HASHMAP_FOREACH(object, card->object_map, i)
2092                 object->assigned = false;
2093
2094         /* preserve existing configurations */
2095         HASHMAP_FOREACH(object, card->object_map, i) {
2096                 if (object->type != GRDRM_TYPE_CRTC || object->assigned)
2097                         continue;
2098
2099                 crtc = crtc_from_object(object);
2100
2101                 if (crtc->applied) {
2102                         /* If our mode is set, preserve it. If no connector is
2103                          * set, modeset either failed or the pipe is unused. In
2104                          * both cases, leave it alone. It might be tried again
2105                          * below in case there're remaining connectors.
2106                          * Otherwise, try restoring the assignments. If they
2107                          * are no longer valid, leave the pipe untouched. */
2108
2109                         if (crtc->set.n_connectors < 1)
2110                                 continue;
2111
2112                         assert(crtc->set.n_connectors == 1);
2113
2114                         object = grdrm_find_object(card, crtc->set.connectors[0]);
2115                         if (!object || object->type != GRDRM_TYPE_CONNECTOR)
2116                                 continue;
2117
2118                         card_configure_crtc(crtc, connector_from_object(object));
2119                 } else if (crtc->kern.mode_set && crtc->kern.n_used_connectors != 1) {
2120                         /* If our mode is not set on the pipe, we know the kern
2121                          * information is valid. Try keeping it. If it's not
2122                          * possible, leave the pipe untouched for later
2123                          * assignements. */
2124
2125                         object = grdrm_find_object(card, crtc->kern.used_connectors[0]);
2126                         if (!object || object->type != GRDRM_TYPE_CONNECTOR)
2127                                 continue;
2128
2129                         card_configure_crtc(crtc, connector_from_object(object));
2130                 }
2131         }
2132
2133         /* assign remaining objects */
2134         HASHMAP_FOREACH(object, card->object_map, i) {
2135                 if (object->type != GRDRM_TYPE_CRTC || object->assigned)
2136                         continue;
2137
2138                 crtc = crtc_from_object(object);
2139
2140                 HASHMAP_FOREACH(object, card->object_map, j) {
2141                         if (object->type != GRDRM_TYPE_CONNECTOR)
2142                                 continue;
2143
2144                         if (card_configure_crtc(crtc, connector_from_object(object)))
2145                                 break;
2146                 }
2147
2148                 if (!crtc->object.assigned)
2149                         grdrm_crtc_assign(crtc, NULL);
2150         }
2151
2152         /* expose configuration */
2153         HASHMAP_FOREACH(object, card->object_map, i) {
2154                 if (object->type != GRDRM_TYPE_CRTC)
2155                         continue;
2156
2157                 grdrm_crtc_expose(crtc_from_object(object));
2158         }
2159 }
2160
2161 static void grdrm_card_hotplug(grdrm_card *card) {
2162         int r;
2163
2164         assert(card);
2165
2166         if (!card->running)
2167                 return;
2168
2169         log_debug("grdrm: %s/%s: reconfigure card", card->base.session->name, card->base.name);
2170
2171         card->ready = false;
2172         r = grdrm_card_resync(card);
2173         if (r < 0) {
2174                 log_debug("grdrm: %s/%s: cannot re-sync card: %s",
2175                           card->base.session->name, card->base.name, strerror(-r));
2176                 return;
2177         }
2178
2179         grdev_session_pin(card->base.session);
2180
2181         /* debug statement to print card information */
2182         if (0)
2183                 grdrm_card_print(card);
2184
2185         grdrm_card_configure(card);
2186         card->ready = true;
2187         card->hotplug = false;
2188
2189         grdev_session_unpin(card->base.session);
2190 }
2191
2192 static int grdrm_card_io_fn(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2193         grdrm_card *card = userdata;
2194         struct drm_event_vblank *vblank;
2195         struct drm_event *event;
2196         uint32_t id, counter;
2197         grdrm_object *object;
2198         char buf[4096];
2199         ssize_t l, i;
2200
2201         if (revents & (EPOLLHUP | EPOLLERR)) {
2202                 /* Immediately close device on HUP; no need to flush pending
2203                  * data.. there're no events we care about here. */
2204                 log_debug("grdrm: %s/%s: HUP", card->base.session->name, card->base.name);
2205                 grdrm_card_close(card);
2206                 return 0;
2207         }
2208
2209         if (revents & (EPOLLIN)) {
2210                 l = read(card->fd, buf, sizeof(buf));
2211                 if (l < 0) {
2212                         if (errno == EAGAIN || errno == EINTR)
2213                                 return 0;
2214
2215                         log_debug("grdrm: %s/%s: read error: %m", card->base.session->name, card->base.name);
2216                         grdrm_card_close(card);
2217                         return 0;
2218                 } else if ((size_t)l < sizeof(*event)) {
2219                         log_debug("grdrm: %s/%s: short read of %zd bytes", card->base.session->name, card->base.name, l);
2220                         return 0;
2221                 }
2222
2223                 for (i = 0; i < l; i += event->length) {
2224                         event = (void*)&buf[i];
2225
2226                         if (i + event->length > l) {
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 }