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         ssize_t l, i;
2199
2200         if (revents & (EPOLLHUP | EPOLLERR)) {
2201                 /* Immediately close device on HUP; no need to flush pending
2202                  * data.. there're no events we care about here. */
2203                 log_debug("grdrm: %s/%s: HUP", card->base.session->name, card->base.name);
2204                 grdrm_card_close(card);
2205                 return 0;
2206         }
2207
2208         if (revents & (EPOLLIN)) {
2209                 l = read(card->fd, buf, sizeof(buf));
2210                 if (l < 0) {
2211                         if (errno == EAGAIN || errno == EINTR)
2212                                 return 0;
2213
2214                         log_debug("grdrm: %s/%s: read error: %m", card->base.session->name, card->base.name);
2215                         grdrm_card_close(card);
2216                         return 0;
2217                 } else if ((size_t)l < sizeof(*event)) {
2218                         log_debug("grdrm: %s/%s: short read of %zd bytes", card->base.session->name, card->base.name, l);
2219                         return 0;
2220                 }
2221
2222                 for (i = 0; i < l; i += event->length) {
2223                         event = (void*)&buf[i];
2224
2225                         if (i + (ssize_t)sizeof(*event) > l || i + (ssize_t)event->length > l) {
2226                                 log_debug("grdrm: %s/%s: truncated event", card->base.session->name, card->base.name);
2227                                 break;
2228                         }
2229
2230                         switch (event->type) {
2231                         case DRM_EVENT_FLIP_COMPLETE:
2232                                 vblank = (void*)event;
2233                                 if (event->length < sizeof(*vblank)) {
2234                                         log_debug("grdrm: %s/%s: truncated vblank event", card->base.session->name, card->base.name);
2235                                         break;
2236                                 }
2237
2238                                 grdrm_decode_vblank_data(vblank->user_data, &id, &counter);
2239                                 object = grdrm_find_object(card, id);
2240                                 if (!object || object->type != GRDRM_TYPE_CRTC)
2241                                         break;
2242
2243                                 grdrm_crtc_flip_complete(crtc_from_object(object), counter, vblank);
2244                                 break;
2245                         }
2246                 }
2247         }
2248
2249         return 0;
2250 }
2251
2252 static int grdrm_card_add(grdrm_card *card, const char *name) {
2253         assert(card);
2254         assert(card->fd < 0);
2255
2256         card->object_map = hashmap_new(&trivial_hash_ops);
2257         if (!card->object_map)
2258                 return -ENOMEM;
2259
2260         return grdev_card_add(&card->base, name);
2261 }
2262
2263 static void grdrm_card_destroy(grdrm_card *card) {
2264         assert(card);
2265         assert(!card->running);
2266         assert(card->fd < 0);
2267         assert(hashmap_size(card->object_map) == 0);
2268
2269         hashmap_free(card->object_map);
2270 }
2271
2272 static void grdrm_card_commit(grdev_card *basecard) {
2273         grdrm_card *card = grdrm_card_from_base(basecard);
2274         grdrm_object *object;
2275         Iterator iter;
2276
2277         HASHMAP_FOREACH(object, card->object_map, iter) {
2278                 if (!card->ready)
2279                         break;
2280
2281                 if (object->type != GRDRM_TYPE_CRTC)
2282                         continue;
2283
2284                 grdrm_crtc_commit(crtc_from_object(object));
2285         }
2286 }
2287
2288 static void grdrm_card_restore(grdev_card *basecard) {
2289         grdrm_card *card = grdrm_card_from_base(basecard);
2290         grdrm_object *object;
2291         Iterator iter;
2292
2293         HASHMAP_FOREACH(object, card->object_map, iter) {
2294                 if (!card->ready)
2295                         break;
2296
2297                 if (object->type != GRDRM_TYPE_CRTC)
2298                         continue;
2299
2300                 grdrm_crtc_restore(crtc_from_object(object));
2301         }
2302 }
2303
2304 static void grdrm_card_enable(grdrm_card *card) {
2305         assert(card);
2306
2307         if (card->fd < 0 || card->running)
2308                 return;
2309
2310         /* ignore cards without DUMB_BUFFER capability */
2311         if (!card->cap_dumb)
2312                 return;
2313
2314         assert(card->fd_src);
2315
2316         log_debug("grdrm: %s/%s: enable", card->base.session->name, card->base.name);
2317
2318         card->running = true;
2319         sd_event_source_set_enabled(card->fd_src, SD_EVENT_ON);
2320         grdrm_card_hotplug(card);
2321 }
2322
2323 static void grdrm_card_disable(grdrm_card *card) {
2324         grdrm_object *object;
2325         Iterator iter;
2326
2327         assert(card);
2328
2329         if (card->fd < 0 || !card->running)
2330                 return;
2331
2332         assert(card->fd_src);
2333
2334         log_debug("grdrm: %s/%s: disable", card->base.session->name, card->base.name);
2335
2336         card->running = false;
2337         card->ready = false;
2338         sd_event_source_set_enabled(card->fd_src, SD_EVENT_OFF);
2339
2340         /* stop all pipes */
2341         HASHMAP_FOREACH(object, card->object_map, iter) {
2342                 grdrm_crtc *crtc;
2343
2344                 if (object->type != GRDRM_TYPE_CRTC)
2345                         continue;
2346
2347                 crtc = crtc_from_object(object);
2348                 crtc->applied = false;
2349                 if (crtc->pipe)
2350                         grdev_pipe_ready(&crtc->pipe->base, false);
2351         }
2352 }
2353
2354 static int grdrm_card_open(grdrm_card *card, int dev_fd) {
2355         _cleanup_(grdev_session_unpinp) grdev_session *pin = NULL;
2356         _cleanup_close_ int fd = dev_fd;
2357         struct drm_get_cap cap;
2358         int r, flags;
2359
2360         assert(card);
2361         assert(dev_fd >= 0);
2362         assert(card->fd != dev_fd);
2363
2364         pin = grdev_session_pin(card->base.session);
2365         grdrm_card_close(card);
2366
2367         log_debug("grdrm: %s/%s: open", card->base.session->name, card->base.name);
2368
2369         r = fd_nonblock(fd, true);
2370         if (r < 0)
2371                 return r;
2372
2373         r = fd_cloexec(fd, true);
2374         if (r < 0)
2375                 return r;
2376
2377         flags = fcntl(fd, F_GETFL, 0);
2378         if (flags < 0)
2379                 return -errno;
2380         if ((flags & O_ACCMODE) != O_RDWR)
2381                 return -EACCES;
2382
2383         r = sd_event_add_io(card->base.session->context->event,
2384                             &card->fd_src,
2385                             fd,
2386                             EPOLLHUP | EPOLLERR | EPOLLIN,
2387                             grdrm_card_io_fn,
2388                             card);
2389         if (r < 0)
2390                 return r;
2391
2392         sd_event_source_set_enabled(card->fd_src, SD_EVENT_OFF);
2393
2394         card->hotplug = true;
2395         card->fd = fd;
2396         fd = -1;
2397
2398         /* cache DUMB_BUFFER capability */
2399         cap.capability = DRM_CAP_DUMB_BUFFER;
2400         cap.value = 0;
2401         r = ioctl(card->fd, DRM_IOCTL_GET_CAP, &cap);
2402         card->cap_dumb = r >= 0 && cap.value;
2403         if (r < 0)
2404                 log_debug("grdrm: %s/%s: cannot retrieve DUMB_BUFFER capability: %s",
2405                           card->base.session->name, card->base.name, strerror(-r));
2406         else if (!card->cap_dumb)
2407                 log_debug("grdrm: %s/%s: DUMB_BUFFER capability not supported",
2408                           card->base.session->name, card->base.name);
2409
2410         /* cache TIMESTAMP_MONOTONIC capability */
2411         cap.capability = DRM_CAP_TIMESTAMP_MONOTONIC;
2412         cap.value = 0;
2413         r = ioctl(card->fd, DRM_IOCTL_GET_CAP, &cap);
2414         card->cap_monotonic = r >= 0 && cap.value;
2415         if (r < 0)
2416                 log_debug("grdrm: %s/%s: cannot retrieve TIMESTAMP_MONOTONIC capability: %s",
2417                           card->base.session->name, card->base.name, strerror(-r));
2418         else if (!card->cap_monotonic)
2419                 log_debug("grdrm: %s/%s: TIMESTAMP_MONOTONIC is disabled globally, fix this NOW!",
2420                           card->base.session->name, card->base.name);
2421
2422         return 0;
2423 }
2424
2425 static void grdrm_card_close(grdrm_card *card) {
2426         grdrm_object *object;
2427
2428         if (card->fd < 0)
2429                 return;
2430
2431         log_debug("grdrm: %s/%s: close", card->base.session->name, card->base.name);
2432
2433         grdrm_card_disable(card);
2434
2435         card->fd_src = sd_event_source_unref(card->fd_src);
2436         card->fd = safe_close(card->fd);
2437
2438         grdev_session_pin(card->base.session);
2439         while ((object = hashmap_first(card->object_map)))
2440                 grdrm_object_free(object);
2441         grdev_session_unpin(card->base.session);
2442 }
2443
2444 static bool grdrm_card_async(grdrm_card *card, int r) {
2445         switch (r) {
2446         case -EACCES:
2447                 /* If we get EACCES on runtime DRM calls, we lost DRM-Master
2448                  * (or we did something terribly wrong). Immediately disable
2449                  * the card, so we stop all pipes and wait to be activated
2450                  * again. */
2451                 grdrm_card_disable(card);
2452                 break;
2453         case -ENOENT:
2454                 /* DRM objects can be hotplugged at any time. If an object is
2455                  * removed that we use, we remember that state so a following
2456                  * call can test for this.
2457                  * Note that we also get a uevent as followup, this will resync
2458                  * the whole device. */
2459                 card->async_hotplug = true;
2460                 break;
2461         }
2462
2463         return !card->ready;
2464 }
2465
2466 /*
2467  * Unmanaged Cards
2468  * The unmanaged DRM card opens the device node for a given DRM device
2469  * directly (/dev/dri/cardX) and thus needs sufficient privileges. It opens
2470  * the device only if we really require it and releases it as soon as we're
2471  * disabled or closed.
2472  * The unmanaged element can be used in all situations where you have direct
2473  * access to DRM device nodes. Unlike managed DRM elements, it can be used
2474  * outside of user sessions and in emergency situations where logind is not
2475  * available.
2476  */
2477
2478 static void unmanaged_card_enable(grdev_card *basecard) {
2479         unmanaged_card *cu = unmanaged_card_from_base(basecard);
2480         int r, fd;
2481
2482         if (cu->card.fd < 0) {
2483                 /* try open on activation if it failed during allocation */
2484                 fd = open(cu->devnode, O_RDWR | O_CLOEXEC | O_NOCTTY | O_NONBLOCK);
2485                 if (fd < 0) {
2486                         /* not fatal; simply ignore the device */
2487                         log_debug("grdrm: %s/%s: cannot open node %s: %m",
2488                                   basecard->session->name, basecard->name, cu->devnode);
2489                         return;
2490                 }
2491
2492                 /* we might already be DRM-Master by open(); that's fine */
2493
2494                 r = grdrm_card_open(&cu->card, fd);
2495                 if (r < 0) {
2496                         log_debug("grdrm: %s/%s: cannot open: %s",
2497                                   basecard->session->name, basecard->name, strerror(-r));
2498                         return;
2499                 }
2500         }
2501
2502         r = ioctl(cu->card.fd, DRM_IOCTL_SET_MASTER, 0);
2503         if (r < 0) {
2504                 log_debug("grdrm: %s/%s: cannot acquire DRM-Master: %m",
2505                           basecard->session->name, basecard->name);
2506                 return;
2507         }
2508
2509         grdrm_card_enable(&cu->card);
2510 }
2511
2512 static void unmanaged_card_disable(grdev_card *basecard) {
2513         unmanaged_card *cu = unmanaged_card_from_base(basecard);
2514
2515         grdrm_card_disable(&cu->card);
2516 }
2517
2518 static int unmanaged_card_new(grdev_card **out, grdev_session *session, struct udev_device *ud) {
2519         _cleanup_(grdev_card_freep) grdev_card *basecard = NULL;
2520         char name[GRDRM_CARD_NAME_MAX];
2521         unmanaged_card *cu;
2522         const char *devnode;
2523         dev_t devnum;
2524         int r, fd;
2525
2526         assert_return(session, -EINVAL);
2527         assert_return(ud, -EINVAL);
2528
2529         devnode = udev_device_get_devnode(ud);
2530         devnum = udev_device_get_devnum(ud);
2531         if (!devnode || devnum == 0)
2532                 return -ENODEV;
2533
2534         grdrm_name(name, devnum);
2535
2536         cu = new0(unmanaged_card, 1);
2537         if (!cu)
2538                 return -ENOMEM;
2539
2540         basecard = &cu->card.base;
2541         cu->card = GRDRM_CARD_INIT(&unmanaged_card_vtable, session);
2542
2543         cu->devnode = strdup(devnode);
2544         if (!cu->devnode)
2545                 return -ENOMEM;
2546
2547         r = grdrm_card_add(&cu->card, name);
2548         if (r < 0)
2549                 return r;
2550
2551         /* try to open but ignore errors */
2552         fd = open(cu->devnode, O_RDWR | O_CLOEXEC | O_NOCTTY | O_NONBLOCK);
2553         if (fd < 0) {
2554                 /* not fatal; allow uaccess based control on activation */
2555                 log_debug("grdrm: %s/%s: cannot open node %s: %m",
2556                           basecard->session->name, basecard->name, cu->devnode);
2557         } else {
2558                 /* We might get DRM-Master implicitly on open(); drop it immediately
2559                  * so we acquire it only once we're actually enabled. We don't
2560                  * really care whether this call fails or not, but lets log any
2561                  * weird errors, anyway. */
2562                 r = ioctl(fd, DRM_IOCTL_DROP_MASTER, 0);
2563                 if (r < 0 && errno != EACCES && errno != EINVAL)
2564                         log_debug("grdrm: %s/%s: cannot drop DRM-Master: %m",
2565                                   basecard->session->name, basecard->name);
2566
2567                 r = grdrm_card_open(&cu->card, fd);
2568                 if (r < 0)
2569                         log_debug("grdrm: %s/%s: cannot open: %s",
2570                                   basecard->session->name, basecard->name, strerror(-r));
2571         }
2572
2573         if (out)
2574                 *out = basecard;
2575         basecard = NULL;
2576         return 0;
2577 }
2578
2579 static void unmanaged_card_free(grdev_card *basecard) {
2580         unmanaged_card *cu = unmanaged_card_from_base(basecard);
2581
2582         assert(!basecard->enabled);
2583
2584         grdrm_card_close(&cu->card);
2585         grdrm_card_destroy(&cu->card);
2586         free(cu->devnode);
2587         free(cu);
2588 }
2589
2590 static const grdev_card_vtable unmanaged_card_vtable = {
2591         .free                   = unmanaged_card_free,
2592         .enable                 = unmanaged_card_enable,
2593         .disable                = unmanaged_card_disable,
2594         .commit                 = grdrm_card_commit,
2595         .restore                = grdrm_card_restore,
2596 };
2597
2598 /*
2599  * Managed Cards
2600  * The managed DRM card uses systemd-logind to acquire DRM devices. This
2601  * means, we do not open the device node /dev/dri/cardX directly. Instead,
2602  * logind passes us a file-descriptor whenever our session is activated. Thus,
2603  * we don't need access to the device node directly.
2604  * Furthermore, whenever the session is put asleep, logind revokes the
2605  * file-descriptor so we loose access to the device.
2606  * Managed DRM cards should be preferred over unmanaged DRM cards whenever
2607  * you run inside a user session with exclusive device access.
2608  */
2609
2610 static void managed_card_enable(grdev_card *card) {
2611         managed_card *cm = managed_card_from_base(card);
2612
2613         /* If the device is manually re-enabled, we try to resume our card
2614          * management. Note that we have no control over DRM-Master and the fd,
2615          * so we have to take over the state from the last logind event. */
2616
2617         if (cm->master)
2618                 grdrm_card_enable(&cm->card);
2619 }
2620
2621 static void managed_card_disable(grdev_card *card) {
2622         managed_card *cm = managed_card_from_base(card);
2623
2624         /* If the device is manually disabled, we keep the FD but put our card
2625          * management asleep. This way, we can wake up at any time, but don't
2626          * touch the device while asleep. */
2627
2628         grdrm_card_disable(&cm->card);
2629 }
2630
2631 static int managed_card_pause_device_fn(sd_bus *bus,
2632                                         sd_bus_message *signal,
2633                                         void *userdata,
2634                                         sd_bus_error *ret_error) {
2635         managed_card *cm = userdata;
2636         grdev_session *session = cm->card.base.session;
2637         uint32_t major, minor;
2638         const char *mode;
2639         int r;
2640
2641         /*
2642          * We get PauseDevice() signals from logind whenever a device we
2643          * requested was, or is about to be, paused. Arguments are major/minor
2644          * number of the device and the mode of the operation.
2645          * In case the event is not about our device, we ignore it. Otherwise,
2646          * we treat it as asynchronous DRM-DROP-MASTER. Note that we might have
2647          * already handled an EACCES error from a modeset ioctl, in which case
2648          * we already disabled the device.
2649          *
2650          * @mode can be one of the following:
2651          *   "pause": The device is about to be paused. We must react
2652          *            immediately and respond with PauseDeviceComplete(). Once
2653          *            we replied, logind will pause the device. Note that
2654          *            logind might apply any kind of timeout and force pause
2655          *            the device if we don't respond in a timely manner. In
2656          *            this case, we will receive a second PauseDevice event
2657          *            with @mode set to "force" (or similar).
2658          *   "force": The device was disabled forecfully by logind. DRM-Master
2659          *            was already dropped. This is just an asynchronous
2660          *            notification so we can put the device asleep (in case
2661          *            we didn't already notice the dropped DRM-Master).
2662          *    "gone": This is like "force" but is sent if the device was
2663          *            paused due to a device-removal event.
2664          *
2665          * We always handle PauseDevice signals as "force" as we properly
2666          * support asynchronously dropping DRM-Master, anyway. But in case
2667          * logind sent mode "pause", we also call PauseDeviceComplete() to
2668          * immediately acknowledge the request.
2669          */
2670
2671         r = sd_bus_message_read(signal, "uus", &major, &minor, &mode);
2672         if (r < 0) {
2673                 log_debug("grdrm: %s/%s: erroneous PauseDevice signal",
2674                           session->name, cm->card.base.name);
2675                 return 0;
2676         }
2677
2678         /* not our device? */
2679         if (makedev(major, minor) != cm->devnum)
2680                 return 0;
2681
2682         cm->master = false;
2683         grdrm_card_disable(&cm->card);
2684
2685         if (streq(mode, "pause")) {
2686                 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2687
2688                 /*
2689                  * Sending PauseDeviceComplete() is racy if logind triggers the
2690                  * timeout. That is, if we take too long and logind pauses the
2691                  * device by sending a forced PauseDevice, our
2692                  * PauseDeviceComplete call will be stray. That's fine, though.
2693                  * logind ignores such stray calls. Only if logind also sent a
2694                  * further PauseDevice() signal, it might match our call
2695                  * incorrectly to the newer PauseDevice(). That's fine, too, as
2696                  * we handle that event asynchronously, anyway. Therefore,
2697                  * whatever happens, we're fine. Yay!
2698                  */
2699
2700                 r = sd_bus_message_new_method_call(session->context->sysbus,
2701                                                    &m,
2702                                                    "org.freedesktop.login1",
2703                                                    session->path,
2704                                                    "org.freedesktop.login1.Session",
2705                                                    "PauseDeviceComplete");
2706                 if (r >= 0) {
2707                         r = sd_bus_message_append(m, "uu", major, minor);
2708                         if (r >= 0)
2709                                 r = sd_bus_send(session->context->sysbus, m, NULL);
2710                 }
2711
2712                 if (r < 0)
2713                         log_debug("grdrm: %s/%s: cannot send PauseDeviceComplete: %s",
2714                                   session->name, cm->card.base.name, strerror(-r));
2715         }
2716
2717         return 0;
2718 }
2719
2720 static int managed_card_resume_device_fn(sd_bus *bus,
2721                                          sd_bus_message *signal,
2722                                          void *userdata,
2723                                          sd_bus_error *ret_error) {
2724         managed_card *cm = userdata;
2725         grdev_session *session = cm->card.base.session;
2726         uint32_t major, minor;
2727         int r, fd;
2728
2729         /*
2730          * We get ResumeDevice signals whenever logind resumed a previously
2731          * paused device. The arguments contain the major/minor number of the
2732          * related device and a new file-descriptor for the freshly opened
2733          * device-node.
2734          * If the signal is not about our device, we simply ignore it.
2735          * Otherwise, we immediately resume the device. Note that we drop the
2736          * new file-descriptor as we already have one from TakeDevice(). logind
2737          * preserves the file-context across pause/resume for DRM but only
2738          * drops/acquires DRM-Master accordingly. This way, our context (like
2739          * DRM-FBs and BOs) is preserved.
2740          */
2741
2742         r = sd_bus_message_read(signal, "uuh", &major, &minor, &fd);
2743         if (r < 0) {
2744                 log_debug("grdrm: %s/%s: erroneous ResumeDevice signal",
2745                           session->name, cm->card.base.name);
2746                 return 0;
2747         }
2748
2749         /* not our device? */
2750         if (makedev(major, minor) != cm->devnum)
2751                 return 0;
2752
2753         if (cm->card.fd < 0) {
2754                 /* This shouldn't happen. We should already own an FD from
2755                  * TakeDevice(). However, lets be safe and use this FD in case
2756                  * we really don't have one. There is no harm in doing this
2757                  * and our code works fine this way. */
2758                 fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
2759                 if (fd < 0) {
2760                         log_debug("grdrm: %s/%s: cannot duplicate fd: %m",
2761                                   session->name, cm->card.base.name);
2762                         return 0;
2763                 }
2764
2765                 r = grdrm_card_open(&cm->card, fd);
2766                 if (r < 0) {
2767                         log_debug("grdrm: %s/%s: cannot open: %s",
2768                                   session->name, cm->card.base.name, strerror(-r));
2769                         return 0;
2770                 }
2771         }
2772
2773         cm->master = true;
2774         if (cm->card.base.enabled)
2775                 grdrm_card_enable(&cm->card);
2776
2777         return 0;
2778 }
2779
2780 static int managed_card_setup_bus(managed_card *cm) {
2781         grdev_session *session = cm->card.base.session;
2782         _cleanup_free_ char *match = NULL;
2783         int r;
2784
2785         match = strjoin("type='signal',"
2786                         "sender='org.freedesktop.login1',"
2787                         "interface='org.freedesktop.login1.Session',"
2788                         "member='PauseDevice',"
2789                         "path='", session->path, "'",
2790                         NULL);
2791         if (!match)
2792                 return -ENOMEM;
2793
2794         r = sd_bus_add_match(session->context->sysbus,
2795                              &cm->slot_pause_device,
2796                              match,
2797                              managed_card_pause_device_fn,
2798                              cm);
2799         if (r < 0)
2800                 return r;
2801
2802         free(match);
2803         match = strjoin("type='signal',"
2804                         "sender='org.freedesktop.login1',"
2805                         "interface='org.freedesktop.login1.Session',"
2806                         "member='ResumeDevice',"
2807                         "path='", session->path, "'",
2808                         NULL);
2809         if (!match)
2810                 return -ENOMEM;
2811
2812         r = sd_bus_add_match(session->context->sysbus,
2813                              &cm->slot_resume_device,
2814                              match,
2815                              managed_card_resume_device_fn,
2816                              cm);
2817         if (r < 0)
2818                 return r;
2819
2820         return 0;
2821 }
2822
2823 static int managed_card_take_device_fn(sd_bus *bus,
2824                                        sd_bus_message *reply,
2825                                        void *userdata,
2826                                        sd_bus_error *ret_error) {
2827         managed_card *cm = userdata;
2828         grdev_session *session = cm->card.base.session;
2829         int r, paused, fd;
2830
2831         cm->slot_take_device = sd_bus_slot_unref(cm->slot_take_device);
2832
2833         if (sd_bus_message_is_method_error(reply, NULL)) {
2834                 const sd_bus_error *error = sd_bus_message_get_error(reply);
2835
2836                 log_debug("grdrm: %s/%s: TakeDevice failed: %s: %s",
2837                           session->name, cm->card.base.name, error->name, error->message);
2838                 return 0;
2839         }
2840
2841         cm->acquired = true;
2842
2843         r = sd_bus_message_read(reply, "hb", &fd, &paused);
2844         if (r < 0) {
2845                 log_debug("grdrm: %s/%s: erroneous TakeDevice reply",
2846                           session->name, cm->card.base.name);
2847                 return 0;
2848         }
2849
2850         fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
2851         if (fd < 0) {
2852                 log_debug("grdrm: %s/%s: cannot duplicate fd: %m",
2853                           session->name, cm->card.base.name);
2854                 return 0;
2855         }
2856
2857         r = grdrm_card_open(&cm->card, fd);
2858         if (r < 0) {
2859                 log_debug("grdrm: %s/%s: cannot open: %s",
2860                           session->name, cm->card.base.name, strerror(-r));
2861                 return 0;
2862         }
2863
2864         if (!paused && cm->card.base.enabled)
2865                 grdrm_card_enable(&cm->card);
2866
2867         return 0;
2868 }
2869
2870 static void managed_card_take_device(managed_card *cm) {
2871         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2872         grdev_session *session = cm->card.base.session;
2873         int r;
2874
2875         r = sd_bus_message_new_method_call(session->context->sysbus,
2876                                            &m,
2877                                            "org.freedesktop.login1",
2878                                            session->path,
2879                                            "org.freedesktop.login1.Session",
2880                                            "TakeDevice");
2881         if (r < 0)
2882                 goto error;
2883
2884         r = sd_bus_message_append(m, "uu", major(cm->devnum), minor(cm->devnum));
2885         if (r < 0)
2886                 goto error;
2887
2888         r = sd_bus_call_async(session->context->sysbus,
2889                               &cm->slot_take_device,
2890                               m,
2891                               managed_card_take_device_fn,
2892                               cm,
2893                               0);
2894         if (r < 0)
2895                 goto error;
2896
2897         cm->requested = true;
2898         return;
2899
2900 error:
2901         log_debug("grdrm: %s/%s: cannot send TakeDevice request: %s",
2902                   session->name, cm->card.base.name, strerror(-r));
2903 }
2904
2905 static void managed_card_release_device(managed_card *cm) {
2906         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2907         grdev_session *session = cm->card.base.session;
2908         int r;
2909
2910         /*
2911          * If TakeDevice() is pending or was successful, make sure to
2912          * release the device again. We don't care for return-values,
2913          * so send it without waiting or callbacks.
2914          * If a failed TakeDevice() is pending, but someone else took
2915          * the device on the same bus-connection, we might incorrectly
2916          * release their device. This is an unlikely race, though.
2917          * Furthermore, you really shouldn't have two users of the
2918          * controller-API on the same session, on the same devices, *AND* on
2919          * the same bus-connection. So we don't care for that race..
2920          */
2921
2922         grdrm_card_close(&cm->card);
2923         cm->requested = false;
2924
2925         if (!cm->acquired && !cm->slot_take_device)
2926                 return;
2927
2928         cm->slot_take_device = sd_bus_slot_unref(cm->slot_take_device);
2929         cm->acquired = false;
2930
2931         r = sd_bus_message_new_method_call(session->context->sysbus,
2932                                            &m,
2933                                            "org.freedesktop.login1",
2934                                            session->path,
2935                                            "org.freedesktop.login1.Session",
2936                                            "ReleaseDevice");
2937         if (r >= 0) {
2938                 r = sd_bus_message_append(m, "uu", major(cm->devnum), minor(cm->devnum));
2939                 if (r >= 0)
2940                         r = sd_bus_send(session->context->sysbus, m, NULL);
2941         }
2942
2943         if (r < 0 && r != -ENOTCONN)
2944                 log_debug("grdrm: %s/%s: cannot send ReleaseDevice: %s",
2945                           session->name, cm->card.base.name, strerror(-r));
2946 }
2947
2948 static int managed_card_new(grdev_card **out, grdev_session *session, struct udev_device *ud) {
2949         _cleanup_(grdev_card_freep) grdev_card *basecard = NULL;
2950         char name[GRDRM_CARD_NAME_MAX];
2951         managed_card *cm;
2952         dev_t devnum;
2953         int r;
2954
2955         assert_return(session, -EINVAL);
2956         assert_return(session->managed, -EINVAL);
2957         assert_return(session->context->sysbus, -EINVAL);
2958         assert_return(ud, -EINVAL);
2959
2960         devnum = udev_device_get_devnum(ud);
2961         if (devnum == 0)
2962                 return -ENODEV;
2963
2964         grdrm_name(name, devnum);
2965
2966         cm = new0(managed_card, 1);
2967         if (!cm)
2968                 return -ENOMEM;
2969
2970         basecard = &cm->card.base;
2971         cm->card = GRDRM_CARD_INIT(&managed_card_vtable, session);
2972         cm->devnum = devnum;
2973
2974         r = managed_card_setup_bus(cm);
2975         if (r < 0)
2976                 return r;
2977
2978         r = grdrm_card_add(&cm->card, name);
2979         if (r < 0)
2980                 return r;
2981
2982         managed_card_take_device(cm);
2983
2984         if (out)
2985                 *out = basecard;
2986         basecard = NULL;
2987         return 0;
2988 }
2989
2990 static void managed_card_free(grdev_card *basecard) {
2991         managed_card *cm = managed_card_from_base(basecard);
2992
2993         assert(!basecard->enabled);
2994
2995         managed_card_release_device(cm);
2996         cm->slot_resume_device = sd_bus_slot_unref(cm->slot_resume_device);
2997         cm->slot_pause_device = sd_bus_slot_unref(cm->slot_pause_device);
2998         grdrm_card_destroy(&cm->card);
2999         free(cm);
3000 }
3001
3002 static const grdev_card_vtable managed_card_vtable = {
3003         .free                   = managed_card_free,
3004         .enable                 = managed_card_enable,
3005         .disable                = managed_card_disable,
3006         .commit                 = grdrm_card_commit,
3007         .restore                = grdrm_card_restore,
3008 };
3009
3010 /*
3011  * Generic Constructor
3012  * Instead of relying on the caller to choose between managed and unmanaged
3013  * DRM devices, the grdev_drm_new() constructor does that for you (by
3014  * looking at session->managed).
3015  */
3016
3017 bool grdev_is_drm_card(grdev_card *basecard) {
3018         return basecard && (basecard->vtable == &unmanaged_card_vtable ||
3019                             basecard->vtable == &managed_card_vtable);
3020 }
3021
3022 grdev_card *grdev_find_drm_card(grdev_session *session, dev_t devnum) {
3023         char name[GRDRM_CARD_NAME_MAX];
3024
3025         assert_return(session, NULL);
3026         assert_return(devnum != 0, NULL);
3027
3028         grdrm_name(name, devnum);
3029         return grdev_find_card(session, name);
3030 }
3031
3032 int grdev_drm_card_new(grdev_card **out, grdev_session *session, struct udev_device *ud) {
3033         assert_return(session, -EINVAL);
3034         assert_return(ud, -EINVAL);
3035
3036         return session->managed ? managed_card_new(out, session, ud) : unmanaged_card_new(out, session, ud);
3037 }
3038
3039 void grdev_drm_card_hotplug(grdev_card *basecard, struct udev_device *ud) {
3040         const char *p, *action;
3041         grdrm_card *card;
3042         dev_t devnum;
3043
3044         assert(basecard);
3045         assert(grdev_is_drm_card(basecard));
3046         assert(ud);
3047
3048         card = grdrm_card_from_base(basecard);
3049
3050         action = udev_device_get_action(ud);
3051         if (!action || streq(action, "add") || streq(action, "remove")) {
3052                 /* If we get add/remove events on DRM nodes without devnum, we
3053                  * got hotplugged DRM objects so refresh the device. */
3054                 devnum = udev_device_get_devnum(ud);
3055                 if (devnum == 0) {
3056                         card->hotplug = true;
3057                         grdrm_card_hotplug(card);
3058                 }
3059         } else if (streq_ptr(action, "change")) {
3060                 /* A change event with HOTPLUG=1 is sent whenever a connector
3061                  * changed state. Refresh the device to update our state. */
3062                 p = udev_device_get_property_value(ud, "HOTPLUG");
3063                 if (streq_ptr(p, "1")) {
3064                         card->hotplug = true;
3065                         grdrm_card_hotplug(card);
3066                 }
3067         }
3068 }