src/libsystemd-terminal/grdev-drm.c

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