src/libsystemd-terminal/grdev-drm.c

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