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