1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright (C) 2014 David Herrmann <dh.herrmann@gmail.com>
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.
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.
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/>.
27 #include <sys/ioctl.h>
29 #include <sys/types.h>
30 #include <systemd/sd-bus.h>
31 #include <systemd/sd-event.h>
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 */
37 #include <drm_fourcc.h>
43 #include "grdev-internal.h"
45 #include "udev-util.h"
48 #define GRDRM_MAX_TRIES (16)
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
;
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
;
79 void (*free_fn
) (grdrm_object
*object
);
102 struct grdrm_connector
{
108 uint32_t used_encoder
;
115 uint32_t max_encoders
;
119 struct drm_mode_modeinfo
*modes
;
123 uint64_t *prop_values
;
127 struct grdrm_encoder
{
148 uint32_t fb_offset_x
;
149 uint32_t fb_offset_y
;
152 uint32_t n_used_connectors
;
153 uint32_t max_used_connectors
;
154 uint32_t *used_connectors
;
157 struct drm_mode_modeinfo mode
;
167 uint32_t n_connectors
;
168 uint32_t *connectors
;
171 struct drm_mode_modeinfo mode
;
175 struct drm_mode_modeinfo mode
;
176 uint32_t n_connectors
;
177 uint32_t max_connectors
;
178 uint32_t *connectors
;
186 #define GRDRM_OBJECT_INIT(_card, _id, _index, _type, _free_fn) ((grdrm_object){ \
191 .free_fn = (_free_fn), \
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
);
198 DEFINE_TRIVIAL_CLEANUP_FUNC(grdrm_object
*, grdrm_object_free
);
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
);
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)
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
);
227 DEFINE_TRIVIAL_CLEANUP_FUNC(grdrm_fb
*, grdrm_fb_free
);
229 #define fb_from_base(_fb) container_of((_fb), grdrm_fb, base)
241 #define grdrm_pipe_from_base(_e) container_of((_e), grdrm_pipe, base)
243 #define GRDRM_PIPE_NAME_MAX (GRDRM_CARD_NAME_MAX + 1 + DECIMAL_STR_MAX(uint32_t))
245 static const grdev_pipe_vtable grdrm_pipe_vtable
;
247 static int grdrm_pipe_new(grdrm_pipe
**out
, grdrm_crtc
*crtc
, struct drm_mode_modeinfo
*mode
, size_t n_fbs
);
257 sd_event_source
*fd_src
;
261 uint32_t n_connectors
;
266 bool async_hotplug
: 1;
271 bool cap_monotonic
: 1;
274 struct unmanaged_card
{
279 struct managed_card
{
283 sd_bus_slot
*slot_pause_device
;
284 sd_bus_slot
*slot_resume_device
;
285 sd_bus_slot
*slot_take_device
;
287 bool requested
: 1; /* TakeDevice() was sent */
288 bool acquired
: 1; /* TakeDevice() was successful */
289 bool master
: 1; /* we are DRM-Master */
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)
298 #define GRDRM_CARD_INIT(_vtable, _session) ((grdrm_card){ \
299 .base = GRDEV_CARD_INIT((_vtable), (_session)), \
304 #define GRDRM_CARD_NAME_MAX (6 + DECIMAL_STR_MAX(unsigned) * 2)
306 static const grdev_card_vtable unmanaged_card_vtable
;
307 static const grdev_card_vtable managed_card_vtable
;
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
);
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.
326 static uint64_t grdrm_encode_vblank_data(uint32_t id
, uint32_t counter
) {
327 return id
| ((uint64_t)counter
<< 32);
330 static void grdrm_decode_vblank_data(uint64_t data
, uint32_t *out_id
, uint32_t *out_counter
) {
332 *out_id
= data
& 0xffffffffU
;
334 *out_counter
= (data
>> 32) & 0xffffffffU
;
337 static bool grdrm_modes_compatible(const struct drm_mode_modeinfo
*a
, const struct drm_mode_modeinfo
*b
) {
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. */
346 if (a
->hdisplay
!= b
->hdisplay
)
348 if (a
->vdisplay
!= b
->vdisplay
)
350 if (a
->vrefresh
!= b
->vrefresh
)
360 grdrm_object
*grdrm_find_object(grdrm_card
*card
, uint32_t id
) {
361 assert_return(card
, NULL
);
363 return id
> 0 ? hashmap_get(card
->object_map
, UINT32_TO_PTR(id
)) : NULL
;
366 int grdrm_object_add(grdrm_object
*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
);
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
);
379 r
= hashmap_put(object
->card
->object_map
, UINT32_TO_PTR(object
->id
), object
);
386 grdrm_object
*grdrm_object_free(grdrm_object
*object
) {
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
);
395 hashmap_remove_value(object
->card
->object_map
, UINT32_TO_PTR(object
->id
), object
);
397 object
->free_fn(object
);
405 static void plane_free(grdrm_object
*object
) {
406 grdrm_plane
*plane
= plane_from_object(object
);
408 free(plane
->kern
.formats
);
409 free(plane
->kern
.crtcs
);
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
;
420 plane
= new0(grdrm_plane
, 1);
424 object
= &plane
->object
;
425 *object
= GRDRM_OBJECT_INIT(card
, id
, index
, GRDRM_TYPE_PLANE
, plane_free
);
427 plane
->kern
.max_crtcs
= 32;
428 plane
->kern
.crtcs
= new0(uint32_t, plane
->kern
.max_crtcs
);
429 if (!plane
->kern
.crtcs
)
432 plane
->kern
.max_formats
= 32;
433 plane
->kern
.formats
= new0(uint32_t, plane
->kern
.max_formats
);
434 if (!plane
->kern
.formats
)
437 r
= grdrm_object_add(object
);
447 static int grdrm_plane_resync(grdrm_plane
*plane
) {
448 grdrm_card
*card
= plane
->object
.card
;
454 for (tries
= 0; tries
< GRDRM_MAX_TRIES
; ++tries
) {
455 struct drm_mode_get_plane res
;
456 grdrm_object
*object
;
457 bool resized
= false;
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
;
465 r
= ioctl(card
->fd
, DRM_IOCTL_MODE_GETPLANE
, &res
);
469 card
->async_hotplug
= true;
471 log_debug("grdrm: %s: plane %u removed during resync",
472 card
->base
.name
, plane
->object
.id
);
474 log_debug_errno(errno
, "grdrm: %s: cannot retrieve plane %u: %m",
475 card
->base
.name
, plane
->object
.id
);
481 plane
->kern
.n_crtcs
= 0;
482 memzero(plane
->kern
.crtcs
, sizeof(uint32_t) * plane
->kern
.max_crtcs
);
484 HASHMAP_FOREACH(object
, card
->object_map
, iter
) {
485 if (object
->type
!= GRDRM_TYPE_CRTC
|| object
->index
>= 32)
487 if (!(res
.possible_crtcs
& (1 << object
->index
)))
489 if (plane
->kern
.n_crtcs
>= 32) {
490 log_debug("grdrm: %s: possible_crtcs of plane %" PRIu32
" exceeds 32bit mask",
491 card
->base
.name
, plane
->object
.id
);
495 plane
->kern
.crtcs
[plane
->kern
.n_crtcs
++] = object
->id
;
498 if (res
.count_format_types
> plane
->kern
.max_formats
) {
501 max
= ALIGN_POWER2(res
.count_format_types
);
502 if (!max
|| max
> UINT16_MAX
) {
503 log_debug("grdrm: %s: excessive plane resource limit: %" PRIu32
, card
->base
.name
, max
);
507 t
= realloc(plane
->kern
.formats
, sizeof(*t
) * max
);
511 plane
->kern
.formats
= t
;
512 plane
->kern
.max_formats
= max
;
519 plane
->kern
.n_formats
= res
.count_format_types
;
520 plane
->kern
.used_crtc
= res
.crtc_id
;
521 plane
->kern
.used_fb
= res
.fb_id
;
522 plane
->kern
.gamma_size
= res
.gamma_size
;
527 if (tries
>= GRDRM_MAX_TRIES
) {
528 log_debug("grdrm: %s: plane %u not settled for retrieval", card
->base
.name
, plane
->object
.id
);
539 static void connector_free(grdrm_object
*object
) {
540 grdrm_connector
*connector
= connector_from_object(object
);
542 free(connector
->kern
.prop_values
);
543 free(connector
->kern
.prop_ids
);
544 free(connector
->kern
.modes
);
545 free(connector
->kern
.encoders
);
549 int grdrm_connector_new(grdrm_connector
**out
, grdrm_card
*card
, uint32_t id
, uint32_t index
) {
550 _cleanup_(grdrm_object_freep
) grdrm_object
*object
= NULL
;
551 grdrm_connector
*connector
;
556 connector
= new0(grdrm_connector
, 1);
560 object
= &connector
->object
;
561 *object
= GRDRM_OBJECT_INIT(card
, id
, index
, GRDRM_TYPE_CONNECTOR
, connector_free
);
563 connector
->kern
.max_encoders
= 32;
564 connector
->kern
.encoders
= new0(uint32_t, connector
->kern
.max_encoders
);
565 if (!connector
->kern
.encoders
)
568 connector
->kern
.max_modes
= 32;
569 connector
->kern
.modes
= new0(struct drm_mode_modeinfo
, connector
->kern
.max_modes
);
570 if (!connector
->kern
.modes
)
573 connector
->kern
.max_props
= 32;
574 connector
->kern
.prop_ids
= new0(uint32_t, connector
->kern
.max_props
);
575 connector
->kern
.prop_values
= new0(uint64_t, connector
->kern
.max_props
);
576 if (!connector
->kern
.prop_ids
|| !connector
->kern
.prop_values
)
579 r
= grdrm_object_add(object
);
589 static int grdrm_connector_resync(grdrm_connector
*connector
) {
590 grdrm_card
*card
= connector
->object
.card
;
596 for (tries
= 0; tries
< GRDRM_MAX_TRIES
; ++tries
) {
597 struct drm_mode_get_connector res
;
598 bool resized
= false;
602 res
.connector_id
= connector
->object
.id
;
603 res
.encoders_ptr
= PTR_TO_UINT64(connector
->kern
.encoders
);
604 res
.props_ptr
= PTR_TO_UINT64(connector
->kern
.prop_ids
);
605 res
.prop_values_ptr
= PTR_TO_UINT64(connector
->kern
.prop_values
);
606 res
.count_encoders
= connector
->kern
.max_encoders
;
607 res
.count_props
= connector
->kern
.max_props
;
609 /* The kernel reads modes from the EDID information only if we
610 * pass count_modes==0. This is a legacy hack for libdrm (which
611 * called every ioctl twice). Now we have to adopt.. *sigh*.
612 * If we never received an hotplug event, there's no reason to
613 * sync modes. EDID reads are heavy, so skip that if not
617 res
.modes_ptr
= PTR_TO_UINT64(connector
->kern
.modes
);
618 res
.count_modes
= connector
->kern
.max_modes
;
624 r
= ioctl(card
->fd
, DRM_IOCTL_MODE_GETCONNECTOR
, &res
);
628 card
->async_hotplug
= true;
630 log_debug("grdrm: %s: connector %u removed during resync",
631 card
->base
.name
, connector
->object
.id
);
633 log_debug_errno(errno
, "grdrm: %s: cannot retrieve connector %u: %m",
634 card
->base
.name
, connector
->object
.id
);
640 if (res
.count_encoders
> connector
->kern
.max_encoders
) {
643 max
= ALIGN_POWER2(res
.count_encoders
);
644 if (!max
|| max
> UINT16_MAX
) {
645 log_debug("grdrm: %s: excessive connector resource limit: %" PRIu32
, card
->base
.name
, max
);
649 t
= realloc(connector
->kern
.encoders
, sizeof(*t
) * max
);
653 connector
->kern
.encoders
= t
;
654 connector
->kern
.max_encoders
= max
;
658 if (res
.count_modes
> connector
->kern
.max_modes
) {
659 struct drm_mode_modeinfo
*t
;
661 max
= ALIGN_POWER2(res
.count_modes
);
662 if (!max
|| max
> UINT16_MAX
) {
663 log_debug("grdrm: %s: excessive connector resource limit: %" PRIu32
, card
->base
.name
, max
);
667 t
= realloc(connector
->kern
.modes
, sizeof(*t
) * max
);
671 connector
->kern
.modes
= t
;
672 connector
->kern
.max_modes
= max
;
676 if (res
.count_props
> connector
->kern
.max_props
) {
680 max
= ALIGN_POWER2(res
.count_props
);
681 if (!max
|| max
> UINT16_MAX
) {
682 log_debug("grdrm: %s: excessive connector resource limit: %" PRIu32
, card
->base
.name
, max
);
686 tids
= realloc(connector
->kern
.prop_ids
, sizeof(*tids
) * max
);
689 connector
->kern
.prop_ids
= tids
;
691 tvals
= realloc(connector
->kern
.prop_values
, sizeof(*tvals
) * max
);
694 connector
->kern
.prop_values
= tvals
;
696 connector
->kern
.max_props
= max
;
703 connector
->kern
.n_encoders
= res
.count_encoders
;
704 connector
->kern
.n_props
= res
.count_props
;
705 connector
->kern
.type
= res
.connector_type
;
706 connector
->kern
.type_id
= res
.connector_type_id
;
707 connector
->kern
.used_encoder
= res
.encoder_id
;
708 connector
->kern
.connection
= res
.connection
;
709 connector
->kern
.mm_width
= res
.mm_width
;
710 connector
->kern
.mm_height
= res
.mm_height
;
711 connector
->kern
.subpixel
= res
.subpixel
;
712 if (res
.modes_ptr
== PTR_TO_UINT64(connector
->kern
.modes
))
713 connector
->kern
.n_modes
= res
.count_modes
;
718 if (tries
>= GRDRM_MAX_TRIES
) {
719 log_debug("grdrm: %s: connector %u not settled for retrieval", card
->base
.name
, connector
->object
.id
);
730 static void encoder_free(grdrm_object
*object
) {
731 grdrm_encoder
*encoder
= encoder_from_object(object
);
733 free(encoder
->kern
.clones
);
734 free(encoder
->kern
.crtcs
);
738 int grdrm_encoder_new(grdrm_encoder
**out
, grdrm_card
*card
, uint32_t id
, uint32_t index
) {
739 _cleanup_(grdrm_object_freep
) grdrm_object
*object
= NULL
;
740 grdrm_encoder
*encoder
;
745 encoder
= new0(grdrm_encoder
, 1);
749 object
= &encoder
->object
;
750 *object
= GRDRM_OBJECT_INIT(card
, id
, index
, GRDRM_TYPE_ENCODER
, encoder_free
);
752 encoder
->kern
.max_crtcs
= 32;
753 encoder
->kern
.crtcs
= new0(uint32_t, encoder
->kern
.max_crtcs
);
754 if (!encoder
->kern
.crtcs
)
757 encoder
->kern
.max_clones
= 32;
758 encoder
->kern
.clones
= new0(uint32_t, encoder
->kern
.max_clones
);
759 if (!encoder
->kern
.clones
)
762 r
= grdrm_object_add(object
);
772 static int grdrm_encoder_resync(grdrm_encoder
*encoder
) {
773 grdrm_card
*card
= encoder
->object
.card
;
774 struct drm_mode_get_encoder res
;
775 grdrm_object
*object
;
782 res
.encoder_id
= encoder
->object
.id
;
784 r
= ioctl(card
->fd
, DRM_IOCTL_MODE_GETENCODER
, &res
);
788 card
->async_hotplug
= true;
790 log_debug("grdrm: %s: encoder %u removed during resync",
791 card
->base
.name
, encoder
->object
.id
);
793 log_debug_errno(errno
, "grdrm: %s: cannot retrieve encoder %u: %m",
794 card
->base
.name
, encoder
->object
.id
);
800 encoder
->kern
.type
= res
.encoder_type
;
801 encoder
->kern
.used_crtc
= res
.crtc_id
;
803 encoder
->kern
.n_crtcs
= 0;
804 memzero(encoder
->kern
.crtcs
, sizeof(uint32_t) * encoder
->kern
.max_crtcs
);
806 HASHMAP_FOREACH(object
, card
->object_map
, iter
) {
807 if (object
->type
!= GRDRM_TYPE_CRTC
|| object
->index
>= 32)
809 if (!(res
.possible_crtcs
& (1 << object
->index
)))
811 if (encoder
->kern
.n_crtcs
>= 32) {
812 log_debug("grdrm: %s: possible_crtcs exceeds 32bit mask", card
->base
.name
);
816 encoder
->kern
.crtcs
[encoder
->kern
.n_crtcs
++] = object
->id
;
819 encoder
->kern
.n_clones
= 0;
820 memzero(encoder
->kern
.clones
, sizeof(uint32_t) * encoder
->kern
.max_clones
);
822 HASHMAP_FOREACH(object
, card
->object_map
, iter
) {
823 if (object
->type
!= GRDRM_TYPE_ENCODER
|| object
->index
>= 32)
825 if (!(res
.possible_clones
& (1 << object
->index
)))
827 if (encoder
->kern
.n_clones
>= 32) {
828 log_debug("grdrm: %s: possible_encoders exceeds 32bit mask", card
->base
.name
);
832 encoder
->kern
.clones
[encoder
->kern
.n_clones
++] = object
->id
;
842 static void crtc_free(grdrm_object
*object
) {
843 grdrm_crtc
*crtc
= crtc_from_object(object
);
846 grdev_pipe_free(&crtc
->pipe
->base
);
847 free(crtc
->set
.connectors
);
848 free(crtc
->old
.connectors
);
849 free(crtc
->kern
.used_connectors
);
853 int grdrm_crtc_new(grdrm_crtc
**out
, grdrm_card
*card
, uint32_t id
, uint32_t index
) {
854 _cleanup_(grdrm_object_freep
) grdrm_object
*object
= NULL
;
860 crtc
= new0(grdrm_crtc
, 1);
864 object
= &crtc
->object
;
865 *object
= GRDRM_OBJECT_INIT(card
, id
, index
, GRDRM_TYPE_CRTC
, crtc_free
);
867 crtc
->kern
.max_used_connectors
= 32;
868 crtc
->kern
.used_connectors
= new0(uint32_t, crtc
->kern
.max_used_connectors
);
869 if (!crtc
->kern
.used_connectors
)
872 crtc
->old
.connectors
= new0(uint32_t, crtc
->kern
.max_used_connectors
);
873 if (!crtc
->old
.connectors
)
876 r
= grdrm_object_add(object
);
886 static int grdrm_crtc_resync(grdrm_crtc
*crtc
) {
887 grdrm_card
*card
= crtc
->object
.card
;
888 struct drm_mode_crtc res
= { .crtc_id
= crtc
->object
.id
};
893 /* make sure we can cache any combination later */
894 if (card
->n_connectors
> crtc
->kern
.max_used_connectors
) {
897 max
= ALIGN_POWER2(card
->n_connectors
);
901 t
= realloc_multiply(crtc
->kern
.used_connectors
, sizeof(*t
), max
);
905 crtc
->kern
.used_connectors
= t
;
906 crtc
->kern
.max_used_connectors
= max
;
908 if (!crtc
->old
.set
) {
909 crtc
->old
.connectors
= calloc(sizeof(*t
), max
);
910 if (!crtc
->old
.connectors
)
915 /* GETCRTC doesn't return connectors. We have to read all
916 * encoder-state and deduce the setup ourselves.. */
917 crtc
->kern
.n_used_connectors
= 0;
919 r
= ioctl(card
->fd
, DRM_IOCTL_MODE_GETCRTC
, &res
);
923 card
->async_hotplug
= true;
925 log_debug("grdrm: %s: crtc %u removed during resync",
926 card
->base
.name
, crtc
->object
.id
);
928 log_debug_errno(errno
, "grdrm: %s: cannot retrieve crtc %u: %m",
929 card
->base
.name
, crtc
->object
.id
);
935 crtc
->kern
.used_fb
= res
.fb_id
;
936 crtc
->kern
.fb_offset_x
= res
.x
;
937 crtc
->kern
.fb_offset_y
= res
.y
;
938 crtc
->kern
.gamma_size
= res
.gamma_size
;
939 crtc
->kern
.mode_set
= res
.mode_valid
;
940 crtc
->kern
.mode
= res
.mode
;
945 static void grdrm_crtc_assign(grdrm_crtc
*crtc
, grdrm_connector
*connector
) {
946 uint32_t n_connectors
;
950 assert(!crtc
->object
.assigned
);
951 assert(!connector
|| !connector
->object
.assigned
);
953 /* always mark both as assigned; even if assignments cannot be set */
954 crtc
->object
.assigned
= true;
956 connector
->object
.assigned
= true;
958 /* we will support hw clone mode in the future */
959 n_connectors
= connector
? 1 : 0;
961 /* bail out if configuration is preserved */
962 if (crtc
->set
.n_connectors
== n_connectors
&&
963 (n_connectors
== 0 || crtc
->set
.connectors
[0] == connector
->object
.id
))
966 crtc
->applied
= false;
967 crtc
->set
.n_connectors
= 0;
969 if (n_connectors
> crtc
->set
.max_connectors
) {
972 max
= ALIGN_POWER2(n_connectors
);
978 t
= realloc(crtc
->set
.connectors
, sizeof(*t
) * max
);
984 crtc
->set
.connectors
= t
;
985 crtc
->set
.max_connectors
= max
;
989 struct drm_mode_modeinfo
*m
, *pref
= NULL
;
992 for (i
= 0; i
< connector
->kern
.n_modes
; ++i
) {
993 m
= &connector
->kern
.modes
[i
];
995 /* ignore 3D modes by default */
996 if (m
->flags
& DRM_MODE_FLAG_3D_MASK
)
1004 /* use PREFERRED over non-PREFERRED */
1005 if ((pref
->type
& DRM_MODE_TYPE_PREFERRED
) &&
1006 !(m
->type
& DRM_MODE_TYPE_PREFERRED
))
1009 /* use DRIVER over non-PREFERRED|DRIVER */
1010 if ((pref
->type
& DRM_MODE_TYPE_DRIVER
) &&
1011 !(m
->type
& (DRM_MODE_TYPE_DRIVER
| DRM_MODE_TYPE_PREFERRED
)))
1014 /* always prefer higher resolution */
1015 if (pref
->hdisplay
> m
->hdisplay
||
1016 (pref
->hdisplay
== m
->hdisplay
&& pref
->vdisplay
> m
->vdisplay
))
1023 crtc
->set
.mode
= *pref
;
1024 crtc
->set
.n_connectors
= 1;
1025 crtc
->set
.connectors
[0] = connector
->object
.id
;
1026 log_debug("grdrm: %s: assigned connector %" PRIu32
" to crtc %" PRIu32
" with mode %s",
1027 crtc
->object
.card
->base
.name
, connector
->object
.id
, crtc
->object
.id
, pref
->name
);
1029 log_debug("grdrm: %s: connector %" PRIu32
" to be assigned but has no valid mode",
1030 crtc
->object
.card
->base
.name
, connector
->object
.id
);
1037 log_debug("grdrm: %s: cannot assign crtc %" PRIu32
": %s",
1038 crtc
->object
.card
->base
.name
, crtc
->object
.id
, strerror(-r
));
1041 static void grdrm_crtc_expose(grdrm_crtc
*crtc
) {
1048 assert(crtc
->object
.assigned
);
1050 if (crtc
->set
.n_connectors
< 1) {
1052 grdev_pipe_free(&crtc
->pipe
->base
);
1059 if (pipe
->base
.width
!= crtc
->set
.mode
.hdisplay
||
1060 pipe
->base
.height
!= crtc
->set
.mode
.vdisplay
||
1061 pipe
->base
.vrefresh
!= crtc
->set
.mode
.vrefresh
) {
1062 grdev_pipe_free(&pipe
->base
);
1069 pipe
->base
.front
= NULL
;
1070 pipe
->base
.back
= NULL
;
1071 for (i
= 0; i
< pipe
->base
.max_fbs
; ++i
) {
1072 fb
= fb_from_base(pipe
->base
.fbs
[i
]);
1073 if (fb
->id
== crtc
->kern
.used_fb
)
1074 pipe
->base
.front
= &fb
->base
;
1075 else if (!fb
->flipid
)
1076 pipe
->base
.back
= &fb
->base
;
1079 r
= grdrm_pipe_new(&pipe
, crtc
, &crtc
->set
.mode
, 2);
1081 log_debug("grdrm: %s: cannot create pipe for crtc %" PRIu32
": %s",
1082 crtc
->object
.card
->base
.name
, crtc
->object
.id
, strerror(-r
));
1086 for (i
= 0; i
< pipe
->base
.max_fbs
; ++i
) {
1087 r
= grdrm_fb_new(&fb
, crtc
->object
.card
, &crtc
->set
.mode
);
1089 log_debug("grdrm: %s: cannot allocate framebuffer for crtc %" PRIu32
": %s",
1090 crtc
->object
.card
->base
.name
, crtc
->object
.id
, strerror(-r
));
1091 grdev_pipe_free(&pipe
->base
);
1095 pipe
->base
.fbs
[i
] = &fb
->base
;
1098 pipe
->base
.front
= NULL
;
1099 pipe
->base
.back
= pipe
->base
.fbs
[0];
1103 grdev_pipe_ready(&crtc
->pipe
->base
, true);
1106 static void grdrm_crtc_commit_deep(grdrm_crtc
*crtc
, grdev_fb
*basefb
) {
1107 struct drm_mode_crtc set_crtc
= { .crtc_id
= crtc
->object
.id
};
1108 grdrm_card
*card
= crtc
->object
.card
;
1109 grdrm_pipe
*pipe
= crtc
->pipe
;
1117 fb
= fb_from_base(basefb
);
1119 set_crtc
.set_connectors_ptr
= PTR_TO_UINT64(crtc
->set
.connectors
);
1120 set_crtc
.count_connectors
= crtc
->set
.n_connectors
;
1121 set_crtc
.fb_id
= fb
->id
;
1124 set_crtc
.mode_valid
= 1;
1125 set_crtc
.mode
= crtc
->set
.mode
;
1127 r
= ioctl(card
->fd
, DRM_IOCTL_MODE_SETCRTC
, &set_crtc
);
1130 log_debug_errno(errno
, "grdrm: %s: cannot set crtc %" PRIu32
": %m",
1131 card
->base
.name
, crtc
->object
.id
);
1133 grdrm_card_async(card
, r
);
1137 if (!crtc
->applied
) {
1138 log_debug("grdrm: %s: crtc %" PRIu32
" applied via deep modeset",
1139 card
->base
.name
, crtc
->object
.id
);
1140 crtc
->applied
= true;
1143 pipe
->base
.back
= NULL
;
1144 pipe
->base
.front
= &fb
->base
;
1147 pipe
->base
.flipping
= false;
1148 pipe
->base
.flip
= false;
1150 /* We cannot schedule dummy page-flips on pipes, hence, the
1151 * application would have to schedule their own frame-timers.
1152 * To avoid duplicating that everywhere, we schedule our own
1153 * timer and raise a fake FRAME event when it fires. */
1154 grdev_pipe_schedule(&pipe
->base
, 1);
1157 static int grdrm_crtc_commit_flip(grdrm_crtc
*crtc
, grdev_fb
*basefb
) {
1158 struct drm_mode_crtc_page_flip page_flip
= { .crtc_id
= crtc
->object
.id
};
1159 grdrm_card
*card
= crtc
->object
.card
;
1160 grdrm_pipe
*pipe
= crtc
->pipe
;
1169 if (!crtc
->applied
) {
1170 if (!grdrm_modes_compatible(&crtc
->kern
.mode
, &crtc
->set
.mode
))
1173 /* TODO: Theoretically, we should be able to page-flip to our
1174 * framebuffer here. We didn't perform any deep modeset, but the
1175 * DRM driver is really supposed to reject our page-flip in case
1176 * the FB is not compatible. We then properly fall back to a
1178 * As it turns out, drivers don't to this. Therefore, we need to
1179 * perform a full modeset on enter now. We might avoid this in
1180 * the future with fixed drivers.. */
1185 fb
= fb_from_base(basefb
);
1187 cnt
= ++pipe
->counter
? : ++pipe
->counter
;
1188 page_flip
.fb_id
= fb
->id
;
1189 page_flip
.flags
= DRM_MODE_PAGE_FLIP_EVENT
;
1190 page_flip
.user_data
= grdrm_encode_vblank_data(crtc
->object
.id
, cnt
);
1192 r
= ioctl(card
->fd
, DRM_IOCTL_MODE_PAGE_FLIP
, &page_flip
);
1195 /* Avoid excessive logging on EINVAL; it is currently not
1196 * possible to see whether cards support page-flipping, so
1197 * avoid logging on each frame. */
1199 log_debug_errno(errno
, "grdrm: %s: cannot schedule page-flip on crtc %" PRIu32
": %m",
1200 card
->base
.name
, crtc
->object
.id
);
1202 if (grdrm_card_async(card
, r
))
1208 if (!crtc
->applied
) {
1209 log_debug("grdrm: %s: crtc %" PRIu32
" applied via page flip",
1210 card
->base
.name
, crtc
->object
.id
);
1211 crtc
->applied
= true;
1214 pipe
->base
.flipping
= true;
1215 pipe
->base
.flip
= false;
1216 pipe
->counter
= cnt
;
1218 pipe
->base
.back
= NULL
;
1220 /* Raise fake FRAME event if it takes longer than 2
1221 * frames to receive the pageflip event. We assume the
1222 * queue ran over or some other error happened. */
1223 grdev_pipe_schedule(&pipe
->base
, 2);
1228 static void grdrm_crtc_commit(grdrm_crtc
*crtc
) {
1229 struct drm_mode_crtc set_crtc
= { .crtc_id
= crtc
->object
.id
};
1230 grdrm_card
*card
= crtc
->object
.card
;
1236 assert(crtc
->object
.assigned
);
1240 /* If a crtc is not assigned any connector, we want any
1241 * previous setup to be cleared, so make sure the CRTC is
1242 * disabled. Otherwise, there might be content on the CRTC
1243 * while we run, which is not what we want.
1244 * If you want to avoid modesets on specific CRTCs, you should
1245 * still keep their assignment, but never enable the resulting
1246 * pipe. This way, we wouldn't touch it at all. */
1247 if (!crtc
->applied
) {
1248 crtc
->applied
= true;
1249 r
= ioctl(card
->fd
, DRM_IOCTL_MODE_SETCRTC
, &set_crtc
);
1252 log_debug_errno(errno
, "grdrm: %s: cannot shutdown crtc %" PRIu32
": %m",
1253 card
->base
.name
, crtc
->object
.id
);
1255 grdrm_card_async(card
, r
);
1259 log_debug("grdrm: %s: crtc %" PRIu32
" applied via shutdown",
1260 card
->base
.name
, crtc
->object
.id
);
1266 /* we always fully ignore disabled pipes */
1267 if (!pipe
->base
.enabled
)
1270 assert(crtc
->set
.n_connectors
> 0);
1272 if (pipe
->base
.flip
)
1273 fb
= pipe
->base
.back
;
1274 else if (!crtc
->applied
)
1275 fb
= pipe
->base
.front
;
1282 r
= grdrm_crtc_commit_flip(crtc
, fb
);
1284 /* in case we couldn't page-flip, perform deep modeset */
1285 grdrm_crtc_commit_deep(crtc
, fb
);
1289 static void grdrm_crtc_restore(grdrm_crtc
*crtc
) {
1290 struct drm_mode_crtc set_crtc
= { .crtc_id
= crtc
->object
.id
};
1291 grdrm_card
*card
= crtc
->object
.card
;
1297 set_crtc
.set_connectors_ptr
= PTR_TO_UINT64(crtc
->old
.connectors
);
1298 set_crtc
.count_connectors
= crtc
->old
.n_connectors
;
1299 set_crtc
.fb_id
= crtc
->old
.fb
;
1300 set_crtc
.x
= crtc
->old
.fb_x
;
1301 set_crtc
.y
= crtc
->old
.fb_y
;
1302 set_crtc
.gamma_size
= crtc
->old
.gamma
;
1303 set_crtc
.mode_valid
= crtc
->old
.mode_set
;
1304 set_crtc
.mode
= crtc
->old
.mode
;
1306 r
= ioctl(card
->fd
, DRM_IOCTL_MODE_SETCRTC
, &set_crtc
);
1309 log_debug_errno(errno
, "grdrm: %s: cannot restore crtc %" PRIu32
": %m",
1310 card
->base
.name
, crtc
->object
.id
);
1312 grdrm_card_async(card
, r
);
1317 ++crtc
->pipe
->counter
;
1318 crtc
->pipe
->base
.front
= NULL
;
1319 crtc
->pipe
->base
.flipping
= false;
1322 log_debug("grdrm: %s: crtc %" PRIu32
" restored", card
->base
.name
, crtc
->object
.id
);
1325 static void grdrm_crtc_flip_complete(grdrm_crtc
*crtc
, uint32_t counter
, struct drm_event_vblank
*event
) {
1326 bool flipped
= false;
1337 /* We got a page-flip event. To be safe, we reset all FBs on the same
1338 * pipe that have smaller flipids than the flip we got as we know they
1339 * are executed in order. We need to do this to guarantee
1340 * queue-overflows or other missed events don't cause starvation.
1341 * Furthermore, if we find the exact FB this event is for, *and* this
1342 * is the most recent event, we mark it as front FB and raise a
1345 for (i
= 0; i
< pipe
->base
.max_fbs
; ++i
) {
1348 if (!pipe
->base
.fbs
[i
])
1351 fb
= fb_from_base(pipe
->base
.fbs
[i
]);
1352 if (counter
!= 0 && counter
== pipe
->counter
&& fb
->flipid
== counter
) {
1353 pipe
->base
.front
= &fb
->base
;
1356 } else if (counter
- fb
->flipid
< UINT16_MAX
) {
1362 crtc
->pipe
->base
.flipping
= false;
1363 grdev_pipe_frame(&pipe
->base
);
1371 static int grdrm_fb_new(grdrm_fb
**out
, grdrm_card
*card
, const struct drm_mode_modeinfo
*mode
) {
1372 _cleanup_(grdrm_fb_freep
) grdrm_fb
*fb
= NULL
;
1373 struct drm_mode_create_dumb create_dumb
= { };
1374 struct drm_mode_map_dumb map_dumb
= { };
1375 struct drm_mode_fb_cmd2 add_fb
= { };
1379 assert_return(out
, -EINVAL
);
1380 assert_return(card
, -EINVAL
);
1382 fb
= new0(grdrm_fb
, 1);
1386 /* TODO: we should choose a compatible format of the previous CRTC
1387 * setting to allow page-flip to it. Only choose fallback if the
1388 * previous setting was crap (non xrgb32'ish). */
1391 fb
->base
.format
= DRM_FORMAT_XRGB8888
;
1392 fb
->base
.width
= mode
->hdisplay
;
1393 fb
->base
.height
= mode
->vdisplay
;
1395 for (i
= 0; i
< ELEMENTSOF(fb
->base
.maps
); ++i
)
1396 fb
->base
.maps
[i
] = MAP_FAILED
;
1398 create_dumb
.width
= fb
->base
.width
;
1399 create_dumb
.height
= fb
->base
.height
;
1400 create_dumb
.bpp
= 32;
1402 r
= ioctl(card
->fd
, DRM_IOCTL_MODE_CREATE_DUMB
, &create_dumb
);
1404 r
= negative_errno();
1405 log_debug_errno(errno
, "grdrm: %s: cannot create dumb buffer %" PRIu32
"x%" PRIu32
": %m",
1406 card
->base
.name
, fb
->base
.width
, fb
->base
.height
);
1410 fb
->handles
[0] = create_dumb
.handle
;
1411 fb
->base
.strides
[0] = create_dumb
.pitch
;
1412 fb
->sizes
[0] = create_dumb
.size
;
1414 map_dumb
.handle
= fb
->handles
[0];
1416 r
= ioctl(card
->fd
, DRM_IOCTL_MODE_MAP_DUMB
, &map_dumb
);
1418 r
= negative_errno();
1419 log_debug_errno(errno
, "grdrm: %s: cannot map dumb buffer %" PRIu32
"x%" PRIu32
": %m",
1420 card
->base
.name
, fb
->base
.width
, fb
->base
.height
);
1424 fb
->base
.maps
[0] = mmap(0, fb
->sizes
[0], PROT_WRITE
, MAP_SHARED
, card
->fd
, map_dumb
.offset
);
1425 if (fb
->base
.maps
[0] == MAP_FAILED
) {
1426 r
= negative_errno();
1427 log_debug_errno(errno
, "grdrm: %s: cannot memory-map dumb buffer %" PRIu32
"x%" PRIu32
": %m",
1428 card
->base
.name
, fb
->base
.width
, fb
->base
.height
);
1432 memzero(fb
->base
.maps
[0], fb
->sizes
[0]);
1434 add_fb
.width
= fb
->base
.width
;
1435 add_fb
.height
= fb
->base
.height
;
1436 add_fb
.pixel_format
= fb
->base
.format
;
1438 memcpy(add_fb
.handles
, fb
->handles
, sizeof(fb
->handles
));
1439 memcpy(add_fb
.pitches
, fb
->base
.strides
, sizeof(fb
->base
.strides
));
1440 memcpy(add_fb
.offsets
, fb
->offsets
, sizeof(fb
->offsets
));
1442 r
= ioctl(card
->fd
, DRM_IOCTL_MODE_ADDFB2
, &add_fb
);
1444 r
= negative_errno();
1445 log_debug_errno(errno
, "grdrm: %s: cannot add framebuffer %" PRIu32
"x%" PRIu32
": %m",
1446 card
->base
.name
, fb
->base
.width
, fb
->base
.height
);
1450 fb
->id
= add_fb
.fb_id
;
1457 grdrm_fb
*grdrm_fb_free(grdrm_fb
*fb
) {
1466 if (fb
->base
.free_fn
)
1467 fb
->base
.free_fn(fb
->base
.data
.ptr
);
1469 if (fb
->id
> 0 && fb
->card
->fd
>= 0) {
1470 r
= ioctl(fb
->card
->fd
, DRM_IOCTL_MODE_RMFB
, fb
->id
);
1472 log_debug_errno(errno
, "grdrm: %s: cannot delete framebuffer %" PRIu32
": %m",
1473 fb
->card
->base
.name
, fb
->id
);
1476 for (i
= 0; i
< ELEMENTSOF(fb
->handles
); ++i
) {
1477 struct drm_mode_destroy_dumb destroy_dumb
= { };
1479 if (fb
->base
.maps
[i
] != MAP_FAILED
)
1480 munmap(fb
->base
.maps
[i
], fb
->sizes
[i
]);
1482 if (fb
->handles
[i
] > 0 && fb
->card
->fd
>= 0) {
1483 destroy_dumb
.handle
= fb
->handles
[i
];
1484 r
= ioctl(fb
->card
->fd
, DRM_IOCTL_MODE_DESTROY_DUMB
, &destroy_dumb
);
1486 log_debug_errno(errno
, "grdrm: %s: cannot destroy dumb-buffer %" PRIu32
": %m",
1487 fb
->card
->base
.name
, fb
->handles
[i
]);
1500 static void grdrm_pipe_name(char *out
, grdrm_crtc
*crtc
) {
1501 /* @out must be at least of size GRDRM_PIPE_NAME_MAX */
1502 sprintf(out
, "%s/%" PRIu32
, crtc
->object
.card
->base
.name
, crtc
->object
.id
);
1505 static int grdrm_pipe_new(grdrm_pipe
**out
, grdrm_crtc
*crtc
, struct drm_mode_modeinfo
*mode
, size_t n_fbs
) {
1506 _cleanup_(grdev_pipe_freep
) grdev_pipe
*basepipe
= NULL
;
1507 grdrm_card
*card
= crtc
->object
.card
;
1508 char name
[GRDRM_PIPE_NAME_MAX
];
1512 assert_return(crtc
, -EINVAL
);
1513 assert_return(grdev_is_drm_card(&card
->base
), -EINVAL
);
1515 pipe
= new0(grdrm_pipe
, 1);
1519 basepipe
= &pipe
->base
;
1520 pipe
->base
= GRDEV_PIPE_INIT(&grdrm_pipe_vtable
, &card
->base
);
1522 pipe
->base
.width
= mode
->hdisplay
;
1523 pipe
->base
.height
= mode
->vdisplay
;
1524 pipe
->base
.vrefresh
= mode
->vrefresh
? : 25;
1526 grdrm_pipe_name(name
, crtc
);
1527 r
= grdev_pipe_add(&pipe
->base
, name
, n_fbs
);
1537 static void grdrm_pipe_free(grdev_pipe
*basepipe
) {
1538 grdrm_pipe
*pipe
= grdrm_pipe_from_base(basepipe
);
1543 for (i
= 0; i
< pipe
->base
.max_fbs
; ++i
)
1544 if (pipe
->base
.fbs
[i
])
1545 grdrm_fb_free(fb_from_base(pipe
->base
.fbs
[i
]));
1550 static grdev_fb
*grdrm_pipe_target(grdev_pipe
*basepipe
) {
1554 if (!basepipe
->back
) {
1555 for (i
= 0; i
< basepipe
->max_fbs
; ++i
) {
1556 if (!basepipe
->fbs
[i
])
1559 fb
= fb_from_base(basepipe
->fbs
[i
]);
1560 if (&fb
->base
== basepipe
->front
)
1562 if (basepipe
->flipping
&& fb
->flipid
)
1565 basepipe
->back
= &fb
->base
;
1570 return basepipe
->back
;
1573 static void grdrm_pipe_enable(grdev_pipe
*basepipe
) {
1574 grdrm_pipe
*pipe
= grdrm_pipe_from_base(basepipe
);
1576 pipe
->crtc
->applied
= false;
1579 static void grdrm_pipe_disable(grdev_pipe
*basepipe
) {
1580 grdrm_pipe
*pipe
= grdrm_pipe_from_base(basepipe
);
1582 pipe
->crtc
->applied
= false;
1585 static const grdev_pipe_vtable grdrm_pipe_vtable
= {
1586 .free
= grdrm_pipe_free
,
1587 .target
= grdrm_pipe_target
,
1588 .enable
= grdrm_pipe_enable
,
1589 .disable
= grdrm_pipe_disable
,
1596 static void grdrm_name(char *out
, dev_t devnum
) {
1597 /* @out must be at least of size GRDRM_CARD_NAME_MAX */
1598 sprintf(out
, "drm/%u:%u", major(devnum
), minor(devnum
));
1601 static void grdrm_card_print(grdrm_card
*card
) {
1602 grdrm_object
*object
;
1604 grdrm_encoder
*encoder
;
1605 grdrm_connector
*connector
;
1611 log_debug("grdrm: %s: state dump", card
->base
.name
);
1613 log_debug(" crtcs:");
1614 HASHMAP_FOREACH(object
, card
->object_map
, iter
) {
1615 if (object
->type
!= GRDRM_TYPE_CRTC
)
1618 crtc
= crtc_from_object(object
);
1619 log_debug(" (id: %u index: %d)", object
->id
, object
->index
);
1621 if (crtc
->kern
.mode_set
)
1622 log_debug(" mode: %dx%d", crtc
->kern
.mode
.hdisplay
, crtc
->kern
.mode
.vdisplay
);
1624 log_debug(" mode: <none>");
1627 log_debug(" encoders:");
1628 HASHMAP_FOREACH(object
, card
->object_map
, iter
) {
1629 if (object
->type
!= GRDRM_TYPE_ENCODER
)
1632 encoder
= encoder_from_object(object
);
1633 log_debug(" (id: %u index: %d)", object
->id
, object
->index
);
1635 if (encoder
->kern
.used_crtc
)
1636 log_debug(" crtc: %u", encoder
->kern
.used_crtc
);
1638 log_debug(" crtc: <none>");
1640 buf
= malloc((DECIMAL_STR_MAX(uint32_t) + 1) * encoder
->kern
.n_crtcs
+ 1);
1645 for (i
= 0; i
< encoder
->kern
.n_crtcs
; ++i
)
1646 p
+= sprintf(p
, " %" PRIu32
, encoder
->kern
.crtcs
[i
]);
1648 log_debug(" possible crtcs:%s", buf
);
1652 buf
= malloc((DECIMAL_STR_MAX(uint32_t) + 1) * encoder
->kern
.n_clones
+ 1);
1657 for (i
= 0; i
< encoder
->kern
.n_clones
; ++i
)
1658 p
+= sprintf(p
, " %" PRIu32
, encoder
->kern
.clones
[i
]);
1660 log_debug(" possible clones:%s", buf
);
1665 log_debug(" connectors:");
1666 HASHMAP_FOREACH(object
, card
->object_map
, iter
) {
1667 if (object
->type
!= GRDRM_TYPE_CONNECTOR
)
1670 connector
= connector_from_object(object
);
1671 log_debug(" (id: %u index: %d)", object
->id
, object
->index
);
1672 log_debug(" type: %" PRIu32
"-%" PRIu32
" connection: %" PRIu32
" subpixel: %" PRIu32
" extents: %" PRIu32
"x%" PRIu32
,
1673 connector
->kern
.type
, connector
->kern
.type_id
, connector
->kern
.connection
, connector
->kern
.subpixel
,
1674 connector
->kern
.mm_width
, connector
->kern
.mm_height
);
1676 if (connector
->kern
.used_encoder
)
1677 log_debug(" encoder: %" PRIu32
, connector
->kern
.used_encoder
);
1679 log_debug(" encoder: <none>");
1681 buf
= malloc((DECIMAL_STR_MAX(uint32_t) + 1) * connector
->kern
.n_encoders
+ 1);
1686 for (i
= 0; i
< connector
->kern
.n_encoders
; ++i
)
1687 p
+= sprintf(p
, " %" PRIu32
, connector
->kern
.encoders
[i
]);
1689 log_debug(" possible encoders:%s", buf
);
1693 for (i
= 0; i
< connector
->kern
.n_modes
; ++i
) {
1694 struct drm_mode_modeinfo
*mode
= &connector
->kern
.modes
[i
];
1695 log_debug(" mode: %" PRIu32
"x%" PRIu32
, mode
->hdisplay
, mode
->vdisplay
);
1699 log_debug(" planes:");
1700 HASHMAP_FOREACH(object
, card
->object_map
, iter
) {
1701 if (object
->type
!= GRDRM_TYPE_PLANE
)
1704 plane
= plane_from_object(object
);
1705 log_debug(" (id: %u index: %d)", object
->id
, object
->index
);
1706 log_debug(" gamma-size: %" PRIu32
, plane
->kern
.gamma_size
);
1708 if (plane
->kern
.used_crtc
)
1709 log_debug(" crtc: %" PRIu32
, plane
->kern
.used_crtc
);
1711 log_debug(" crtc: <none>");
1713 buf
= malloc((DECIMAL_STR_MAX(uint32_t) + 1) * plane
->kern
.n_crtcs
+ 1);
1718 for (i
= 0; i
< plane
->kern
.n_crtcs
; ++i
)
1719 p
+= sprintf(p
, " %" PRIu32
, plane
->kern
.crtcs
[i
]);
1721 log_debug(" possible crtcs:%s", buf
);
1725 buf
= malloc((DECIMAL_STR_MAX(unsigned int) + 3) * plane
->kern
.n_formats
+ 1);
1730 for (i
= 0; i
< plane
->kern
.n_formats
; ++i
)
1731 p
+= sprintf(p
, " 0x%x", (unsigned int)plane
->kern
.formats
[i
]);
1733 log_debug(" possible formats:%s", buf
);
1739 static int grdrm_card_resync(grdrm_card
*card
) {
1740 _cleanup_free_
uint32_t *crtc_ids
= NULL
, *encoder_ids
= NULL
, *connector_ids
= NULL
, *plane_ids
= NULL
;
1741 uint32_t allocated
= 0;
1742 grdrm_object
*object
;
1749 card
->async_hotplug
= false;
1752 /* mark existing objects for possible removal */
1753 HASHMAP_FOREACH(object
, card
->object_map
, iter
)
1754 object
->present
= false;
1756 for (tries
= 0; tries
< GRDRM_MAX_TRIES
; ++tries
) {
1757 struct drm_mode_get_plane_res pres
;
1758 struct drm_mode_card_res res
;
1761 if (allocated
< card
->max_ids
) {
1764 free(connector_ids
);
1766 crtc_ids
= new0(uint32_t, card
->max_ids
);
1767 encoder_ids
= new0(uint32_t, card
->max_ids
);
1768 connector_ids
= new0(uint32_t, card
->max_ids
);
1769 plane_ids
= new0(uint32_t, card
->max_ids
);
1771 if (!crtc_ids
|| !encoder_ids
|| !connector_ids
|| !plane_ids
)
1774 allocated
= card
->max_ids
;
1778 res
.crtc_id_ptr
= PTR_TO_UINT64(crtc_ids
);
1779 res
.connector_id_ptr
= PTR_TO_UINT64(connector_ids
);
1780 res
.encoder_id_ptr
= PTR_TO_UINT64(encoder_ids
);
1781 res
.count_crtcs
= allocated
;
1782 res
.count_encoders
= allocated
;
1783 res
.count_connectors
= allocated
;
1785 r
= ioctl(card
->fd
, DRM_IOCTL_MODE_GETRESOURCES
, &res
);
1788 log_debug_errno(errno
, "grdrm: %s: cannot retrieve drm resources: %m",
1794 pres
.plane_id_ptr
= PTR_TO_UINT64(plane_ids
);
1795 pres
.count_planes
= allocated
;
1797 r
= ioctl(card
->fd
, DRM_IOCTL_MODE_GETPLANERESOURCES
, &pres
);
1800 log_debug_errno(errno
, "grdrm: %s: cannot retrieve drm plane-resources: %m",
1805 max
= MAX(MAX(res
.count_crtcs
, res
.count_encoders
),
1806 MAX(res
.count_connectors
, pres
.count_planes
));
1807 if (max
> allocated
) {
1810 n
= ALIGN_POWER2(max
);
1811 if (!n
|| n
> UINT16_MAX
) {
1812 log_debug("grdrm: %s: excessive DRM resource limit: %" PRIu32
,
1813 card
->base
.name
, max
);
1817 /* retry with resized buffers */
1822 /* mark available objects as present */
1824 for (i
= 0; i
< res
.count_crtcs
; ++i
) {
1825 object
= grdrm_find_object(card
, crtc_ids
[i
]);
1826 if (object
&& object
->type
== GRDRM_TYPE_CRTC
) {
1827 object
->present
= true;
1833 for (i
= 0; i
< res
.count_encoders
; ++i
) {
1834 object
= grdrm_find_object(card
, encoder_ids
[i
]);
1835 if (object
&& object
->type
== GRDRM_TYPE_ENCODER
) {
1836 object
->present
= true;
1842 for (i
= 0; i
< res
.count_connectors
; ++i
) {
1843 object
= grdrm_find_object(card
, connector_ids
[i
]);
1844 if (object
&& object
->type
== GRDRM_TYPE_CONNECTOR
) {
1845 object
->present
= true;
1847 connector_ids
[i
] = 0;
1851 for (i
= 0; i
< pres
.count_planes
; ++i
) {
1852 object
= grdrm_find_object(card
, plane_ids
[i
]);
1853 if (object
&& object
->type
== GRDRM_TYPE_PLANE
) {
1854 object
->present
= true;
1860 /* drop removed objects */
1862 HASHMAP_FOREACH(object
, card
->object_map
, iter
)
1863 if (!object
->present
)
1864 grdrm_object_free(object
);
1866 /* add new objects */
1868 card
->n_crtcs
= res
.count_crtcs
;
1869 for (i
= 0; i
< res
.count_crtcs
; ++i
) {
1870 if (crtc_ids
[i
] < 1)
1873 r
= grdrm_crtc_new(NULL
, card
, crtc_ids
[i
], i
);
1878 card
->n_encoders
= res
.count_encoders
;
1879 for (i
= 0; i
< res
.count_encoders
; ++i
) {
1880 if (encoder_ids
[i
] < 1)
1883 r
= grdrm_encoder_new(NULL
, card
, encoder_ids
[i
], i
);
1888 card
->n_connectors
= res
.count_connectors
;
1889 for (i
= 0; i
< res
.count_connectors
; ++i
) {
1890 if (connector_ids
[i
] < 1)
1893 r
= grdrm_connector_new(NULL
, card
, connector_ids
[i
], i
);
1898 card
->n_planes
= pres
.count_planes
;
1899 for (i
= 0; i
< pres
.count_planes
; ++i
) {
1900 if (plane_ids
[i
] < 1)
1903 r
= grdrm_plane_new(NULL
, card
, plane_ids
[i
], i
);
1908 /* re-sync objects after object_map is synced */
1910 HASHMAP_FOREACH(object
, card
->object_map
, iter
) {
1911 switch (object
->type
) {
1912 case GRDRM_TYPE_CRTC
:
1913 r
= grdrm_crtc_resync(crtc_from_object(object
));
1915 case GRDRM_TYPE_ENCODER
:
1916 r
= grdrm_encoder_resync(encoder_from_object(object
));
1918 case GRDRM_TYPE_CONNECTOR
:
1919 r
= grdrm_connector_resync(connector_from_object(object
));
1921 case GRDRM_TYPE_PLANE
:
1922 r
= grdrm_plane_resync(plane_from_object(object
));
1925 assert_not_reached("grdrm: invalid object type");
1932 if (card
->async_hotplug
)
1936 /* if modeset objects change during sync, start over */
1937 if (card
->async_hotplug
) {
1938 card
->async_hotplug
= false;
1942 /* cache crtc/connector relationship */
1943 HASHMAP_FOREACH(object
, card
->object_map
, iter
) {
1944 grdrm_connector
*connector
;
1945 grdrm_encoder
*encoder
;
1948 if (object
->type
!= GRDRM_TYPE_CONNECTOR
)
1951 connector
= connector_from_object(object
);
1952 if (connector
->kern
.connection
!= 1 || connector
->kern
.used_encoder
< 1)
1955 object
= grdrm_find_object(card
, connector
->kern
.used_encoder
);
1956 if (!object
|| object
->type
!= GRDRM_TYPE_ENCODER
)
1959 encoder
= encoder_from_object(object
);
1960 if (encoder
->kern
.used_crtc
< 1)
1963 object
= grdrm_find_object(card
, encoder
->kern
.used_crtc
);
1964 if (!object
|| object
->type
!= GRDRM_TYPE_CRTC
)
1967 crtc
= crtc_from_object(object
);
1968 assert(crtc
->kern
.n_used_connectors
< crtc
->kern
.max_used_connectors
);
1969 crtc
->kern
.used_connectors
[crtc
->kern
.n_used_connectors
++] = connector
->object
.id
;
1972 /* cache old crtc settings for later restore */
1973 HASHMAP_FOREACH(object
, card
->object_map
, iter
) {
1976 if (object
->type
!= GRDRM_TYPE_CRTC
)
1979 crtc
= crtc_from_object(object
);
1981 /* Save data if it is the first time we refresh the CRTC. This data can
1982 * be used optionally to restore any previous configuration. For
1983 * instance, it allows us to restore VT configurations after we close
1984 * our session again. */
1985 if (!crtc
->old
.set
) {
1986 crtc
->old
.fb
= crtc
->kern
.used_fb
;
1987 crtc
->old
.fb_x
= crtc
->kern
.fb_offset_x
;
1988 crtc
->old
.fb_y
= crtc
->kern
.fb_offset_y
;
1989 crtc
->old
.gamma
= crtc
->kern
.gamma_size
;
1990 crtc
->old
.n_connectors
= crtc
->kern
.n_used_connectors
;
1991 if (crtc
->old
.n_connectors
)
1992 memcpy(crtc
->old
.connectors
, crtc
->kern
.used_connectors
, sizeof(uint32_t) * crtc
->old
.n_connectors
);
1993 crtc
->old
.mode_set
= crtc
->kern
.mode_set
;
1994 crtc
->old
.mode
= crtc
->kern
.mode
;
1995 crtc
->old
.set
= true;
1999 /* everything synced */
2003 if (tries
>= GRDRM_MAX_TRIES
) {
2005 * Ugh! We were unable to sync the DRM card state due to heavy
2006 * hotplugging. This should never happen, so print a debug
2007 * message and bail out. The next uevent will trigger
2011 log_debug("grdrm: %s: hotplug-storm when syncing card", card
->base
.name
);
2018 static bool card_configure_crtc(grdrm_crtc
*crtc
, grdrm_connector
*connector
) {
2019 grdrm_card
*card
= crtc
->object
.card
;
2020 grdrm_encoder
*encoder
;
2021 grdrm_object
*object
;
2024 if (crtc
->object
.assigned
|| connector
->object
.assigned
)
2026 if (connector
->kern
.connection
!= 1)
2029 for (i
= 0; i
< connector
->kern
.n_encoders
; ++i
) {
2030 object
= grdrm_find_object(card
, connector
->kern
.encoders
[i
]);
2031 if (!object
|| object
->type
!= GRDRM_TYPE_ENCODER
)
2034 encoder
= encoder_from_object(object
);
2035 for (j
= 0; j
< encoder
->kern
.n_crtcs
; ++j
) {
2036 if (encoder
->kern
.crtcs
[j
] == crtc
->object
.id
) {
2037 grdrm_crtc_assign(crtc
, connector
);
2046 static void grdrm_card_configure(grdrm_card
*card
) {
2048 * Modeset Configuration
2049 * This is where we update our modeset configuration and assign
2050 * connectors to CRTCs. This means, each connector that we want to
2051 * enable needs a CRTC, disabled (or unavailable) connectors are left
2052 * alone in the dark. Once all CRTCs are assigned, the remaining CRTCs
2054 * Sounds trivial, but there're several caveats:
2056 * * Multiple connectors can be driven by the same CRTC. This is
2057 * known as 'hardware clone mode'. Advantage over software clone
2058 * mode is that only a single CRTC is needed to drive multiple
2059 * displays. However, few hardware supports this and it's a huge
2060 * headache to configure on dynamic demands. Therefore, we only
2061 * support it if configured statically beforehand.
2063 * * CRTCs are not created equal. Some might be much more powerful
2064 * than others, including more advanced plane support. So far, our
2065 * CRTC selection is random. You need to supply static
2066 * configuration if you want special setups. So far, there is no
2067 * proper way to do advanced CRTC selection on dynamic demands. It
2068 * is not really clear which demands require what CRTC, so, like
2069 * everyone else, we do random CRTC selection unless explicitly
2072 * * Each Connector has a list of possible encoders that can drive
2073 * it, and each encoder has a list of possible CRTCs. If this graph
2074 * is a tree, assignment is trivial. However, if not, we cannot
2075 * reliably decide on configurations beforehand. The encoder is
2076 * always selected by the kernel, so we have to actually set a mode
2077 * to know which encoder is used. There is no way to ask the kernel
2078 * whether a given configuration is possible. This will change with
2079 * atomic-modesetting, but until then, we keep our configurations
2080 * simple and assume they work all just fine. If one fails
2081 * unexpectedly, we print a warning and disable it.
2083 * Configuring a card consists of several steps:
2085 * 1) First of all, we apply any user-configuration. If a user wants
2086 * a fixed configuration, we apply it and preserve it.
2087 * So far, we don't support user configuration files, so this step
2090 * 2) Secondly, we need to apply any quirks from hwdb. Some hardware
2091 * might only support limited configurations or require special
2092 * CRTC/Connector mappings. We read this from hwdb and apply it, if
2094 * So far, we don't support this as there is no known quirk, so
2095 * this step is skipped.
2097 * 3) As deep modesets are expensive, we try to avoid them if
2098 * possible. Therefore, we read the current configuration from the
2099 * kernel and try to preserve it, if compatible with our demands.
2100 * If not, we break it and reassign it in a following step.
2102 * 4) The main step involves configuring all remaining objects. By
2103 * default, all available connectors are enabled, except for those
2104 * disabled by user-configuration. We lookup a suitable CRTC for
2105 * each connector and assign them. As there might be more
2106 * connectors than CRTCs, we apply some ordering so users can
2107 * select which connectors are more important right now.
2108 * So far, we only apply the default ordering, more might be added
2112 grdrm_object
*object
;
2116 /* clear assignments */
2117 HASHMAP_FOREACH(object
, card
->object_map
, i
)
2118 object
->assigned
= false;
2120 /* preserve existing configurations */
2121 HASHMAP_FOREACH(object
, card
->object_map
, i
) {
2122 if (object
->type
!= GRDRM_TYPE_CRTC
|| object
->assigned
)
2125 crtc
= crtc_from_object(object
);
2127 if (crtc
->applied
) {
2128 /* If our mode is set, preserve it. If no connector is
2129 * set, modeset either failed or the pipe is unused. In
2130 * both cases, leave it alone. It might be tried again
2131 * below in case there're remaining connectors.
2132 * Otherwise, try restoring the assignments. If they
2133 * are no longer valid, leave the pipe untouched. */
2135 if (crtc
->set
.n_connectors
< 1)
2138 assert(crtc
->set
.n_connectors
== 1);
2140 object
= grdrm_find_object(card
, crtc
->set
.connectors
[0]);
2141 if (!object
|| object
->type
!= GRDRM_TYPE_CONNECTOR
)
2144 card_configure_crtc(crtc
, connector_from_object(object
));
2145 } else if (crtc
->kern
.mode_set
&& crtc
->kern
.n_used_connectors
!= 1) {
2146 /* If our mode is not set on the pipe, we know the kern
2147 * information is valid. Try keeping it. If it's not
2148 * possible, leave the pipe untouched for later
2151 object
= grdrm_find_object(card
, crtc
->kern
.used_connectors
[0]);
2152 if (!object
|| object
->type
!= GRDRM_TYPE_CONNECTOR
)
2155 card_configure_crtc(crtc
, connector_from_object(object
));
2159 /* assign remaining objects */
2160 HASHMAP_FOREACH(object
, card
->object_map
, i
) {
2161 if (object
->type
!= GRDRM_TYPE_CRTC
|| object
->assigned
)
2164 crtc
= crtc_from_object(object
);
2166 HASHMAP_FOREACH(object
, card
->object_map
, j
) {
2167 if (object
->type
!= GRDRM_TYPE_CONNECTOR
)
2170 if (card_configure_crtc(crtc
, connector_from_object(object
)))
2174 if (!crtc
->object
.assigned
)
2175 grdrm_crtc_assign(crtc
, NULL
);
2178 /* expose configuration */
2179 HASHMAP_FOREACH(object
, card
->object_map
, i
) {
2180 if (object
->type
!= GRDRM_TYPE_CRTC
)
2183 grdrm_crtc_expose(crtc_from_object(object
));
2187 static void grdrm_card_hotplug(grdrm_card
*card
) {
2195 log_debug("grdrm: %s/%s: reconfigure card", card
->base
.session
->name
, card
->base
.name
);
2197 card
->ready
= false;
2198 r
= grdrm_card_resync(card
);
2200 log_debug_errno(r
, "grdrm: %s/%s: cannot re-sync card: %m",
2201 card
->base
.session
->name
, card
->base
.name
);
2205 grdev_session_pin(card
->base
.session
);
2207 /* debug statement to print card information */
2209 grdrm_card_print(card
);
2211 grdrm_card_configure(card
);
2213 card
->hotplug
= false;
2215 grdev_session_unpin(card
->base
.session
);
2218 static int grdrm_card_io_fn(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
2219 grdrm_card
*card
= userdata
;
2220 struct drm_event_vblank
*vblank
;
2221 struct drm_event
*event
;
2222 uint32_t id
, counter
;
2223 grdrm_object
*object
;
2228 if (revents
& (EPOLLHUP
| EPOLLERR
)) {
2229 /* Immediately close device on HUP; no need to flush pending
2230 * data.. there're no events we care about here. */
2231 log_debug("grdrm: %s/%s: HUP", card
->base
.session
->name
, card
->base
.name
);
2232 grdrm_card_close(card
);
2236 if (revents
& (EPOLLIN
)) {
2237 l
= read(card
->fd
, buf
, sizeof(buf
));
2239 if (errno
== EAGAIN
|| errno
== EINTR
)
2242 log_debug_errno(errno
, "grdrm: %s/%s: read error: %m",
2243 card
->base
.session
->name
, card
->base
.name
);
2244 grdrm_card_close(card
);
2248 for (len
= l
; len
> 0; len
-= event
->length
) {
2251 if (len
< sizeof(*event
) || len
< event
->length
) {
2252 log_debug("grdrm: %s/%s: truncated event",
2253 card
->base
.session
->name
, card
->base
.name
);
2257 switch (event
->type
) {
2258 case DRM_EVENT_FLIP_COMPLETE
:
2259 vblank
= (void*)event
;
2260 if (event
->length
< sizeof(*vblank
)) {
2261 log_debug("grdrm: %s/%s: truncated vblank event",
2262 card
->base
.session
->name
, card
->base
.name
);
2266 grdrm_decode_vblank_data(vblank
->user_data
, &id
, &counter
);
2267 object
= grdrm_find_object(card
, id
);
2268 if (!object
|| object
->type
!= GRDRM_TYPE_CRTC
)
2271 grdrm_crtc_flip_complete(crtc_from_object(object
), counter
, vblank
);
2280 static int grdrm_card_add(grdrm_card
*card
, const char *name
) {
2282 assert(card
->fd
< 0);
2284 card
->object_map
= hashmap_new(&trivial_hash_ops
);
2285 if (!card
->object_map
)
2288 return grdev_card_add(&card
->base
, name
);
2291 static void grdrm_card_destroy(grdrm_card
*card
) {
2293 assert(!card
->running
);
2294 assert(card
->fd
< 0);
2295 assert(hashmap_size(card
->object_map
) == 0);
2297 hashmap_free(card
->object_map
);
2300 static void grdrm_card_commit(grdev_card
*basecard
) {
2301 grdrm_card
*card
= grdrm_card_from_base(basecard
);
2302 grdrm_object
*object
;
2305 HASHMAP_FOREACH(object
, card
->object_map
, iter
) {
2309 if (object
->type
!= GRDRM_TYPE_CRTC
)
2312 grdrm_crtc_commit(crtc_from_object(object
));
2316 static void grdrm_card_restore(grdev_card
*basecard
) {
2317 grdrm_card
*card
= grdrm_card_from_base(basecard
);
2318 grdrm_object
*object
;
2321 HASHMAP_FOREACH(object
, card
->object_map
, iter
) {
2325 if (object
->type
!= GRDRM_TYPE_CRTC
)
2328 grdrm_crtc_restore(crtc_from_object(object
));
2332 static void grdrm_card_enable(grdrm_card
*card
) {
2335 if (card
->fd
< 0 || card
->running
)
2338 /* ignore cards without DUMB_BUFFER capability */
2339 if (!card
->cap_dumb
)
2342 assert(card
->fd_src
);
2344 log_debug("grdrm: %s/%s: enable", card
->base
.session
->name
, card
->base
.name
);
2346 card
->running
= true;
2347 sd_event_source_set_enabled(card
->fd_src
, SD_EVENT_ON
);
2348 grdrm_card_hotplug(card
);
2351 static void grdrm_card_disable(grdrm_card
*card
) {
2352 grdrm_object
*object
;
2357 if (card
->fd
< 0 || !card
->running
)
2360 assert(card
->fd_src
);
2362 log_debug("grdrm: %s/%s: disable", card
->base
.session
->name
, card
->base
.name
);
2364 card
->running
= false;
2365 card
->ready
= false;
2366 sd_event_source_set_enabled(card
->fd_src
, SD_EVENT_OFF
);
2368 /* stop all pipes */
2369 HASHMAP_FOREACH(object
, card
->object_map
, iter
) {
2372 if (object
->type
!= GRDRM_TYPE_CRTC
)
2375 crtc
= crtc_from_object(object
);
2376 crtc
->applied
= false;
2378 grdev_pipe_ready(&crtc
->pipe
->base
, false);
2382 static int grdrm_card_open(grdrm_card
*card
, int dev_fd
) {
2383 _cleanup_(grdev_session_unpinp
) grdev_session
*pin
= NULL
;
2384 _cleanup_close_
int fd
= dev_fd
;
2385 struct drm_get_cap cap
;
2389 assert(dev_fd
>= 0);
2390 assert(card
->fd
!= dev_fd
);
2392 pin
= grdev_session_pin(card
->base
.session
);
2393 grdrm_card_close(card
);
2395 log_debug("grdrm: %s/%s: open", card
->base
.session
->name
, card
->base
.name
);
2397 r
= fd_nonblock(fd
, true);
2401 r
= fd_cloexec(fd
, true);
2405 flags
= fcntl(fd
, F_GETFL
, 0);
2408 if ((flags
& O_ACCMODE
) != O_RDWR
)
2411 r
= sd_event_add_io(card
->base
.session
->context
->event
,
2414 EPOLLHUP
| EPOLLERR
| EPOLLIN
,
2420 sd_event_source_set_enabled(card
->fd_src
, SD_EVENT_OFF
);
2422 card
->hotplug
= true;
2426 /* cache DUMB_BUFFER capability */
2427 cap
.capability
= DRM_CAP_DUMB_BUFFER
;
2429 r
= ioctl(card
->fd
, DRM_IOCTL_GET_CAP
, &cap
);
2430 card
->cap_dumb
= r
>= 0 && cap
.value
;
2432 log_debug_errno(r
, "grdrm: %s/%s: cannot retrieve DUMB_BUFFER capability: %m",
2433 card
->base
.session
->name
, card
->base
.name
);
2434 else if (!card
->cap_dumb
)
2435 log_debug("grdrm: %s/%s: DUMB_BUFFER capability not supported",
2436 card
->base
.session
->name
, card
->base
.name
);
2438 /* cache TIMESTAMP_MONOTONIC capability */
2439 cap
.capability
= DRM_CAP_TIMESTAMP_MONOTONIC
;
2441 r
= ioctl(card
->fd
, DRM_IOCTL_GET_CAP
, &cap
);
2442 card
->cap_monotonic
= r
>= 0 && cap
.value
;
2444 log_debug_errno(r
, "grdrm: %s/%s: cannot retrieve TIMESTAMP_MONOTONIC capability: %m",
2445 card
->base
.session
->name
, card
->base
.name
);
2446 else if (!card
->cap_monotonic
)
2447 log_debug("grdrm: %s/%s: TIMESTAMP_MONOTONIC is disabled globally, fix this NOW!",
2448 card
->base
.session
->name
, card
->base
.name
);
2453 static void grdrm_card_close(grdrm_card
*card
) {
2454 grdrm_object
*object
;
2459 log_debug("grdrm: %s/%s: close", card
->base
.session
->name
, card
->base
.name
);
2461 grdrm_card_disable(card
);
2463 card
->fd_src
= sd_event_source_unref(card
->fd_src
);
2464 card
->fd
= safe_close(card
->fd
);
2466 grdev_session_pin(card
->base
.session
);
2467 while ((object
= hashmap_first(card
->object_map
)))
2468 grdrm_object_free(object
);
2469 grdev_session_unpin(card
->base
.session
);
2472 static bool grdrm_card_async(grdrm_card
*card
, int r
) {
2475 /* If we get EACCES on runtime DRM calls, we lost DRM-Master
2476 * (or we did something terribly wrong). Immediately disable
2477 * the card, so we stop all pipes and wait to be activated
2479 grdrm_card_disable(card
);
2482 /* DRM objects can be hotplugged at any time. If an object is
2483 * removed that we use, we remember that state so a following
2484 * call can test for this.
2485 * Note that we also get a uevent as followup, this will resync
2486 * the whole device. */
2487 card
->async_hotplug
= true;
2491 return !card
->ready
;
2496 * The unmanaged DRM card opens the device node for a given DRM device
2497 * directly (/dev/dri/cardX) and thus needs sufficient privileges. It opens
2498 * the device only if we really require it and releases it as soon as we're
2499 * disabled or closed.
2500 * The unmanaged element can be used in all situations where you have direct
2501 * access to DRM device nodes. Unlike managed DRM elements, it can be used
2502 * outside of user sessions and in emergency situations where logind is not
2506 static void unmanaged_card_enable(grdev_card
*basecard
) {
2507 unmanaged_card
*cu
= unmanaged_card_from_base(basecard
);
2510 if (cu
->card
.fd
< 0) {
2511 /* try open on activation if it failed during allocation */
2512 fd
= open(cu
->devnode
, O_RDWR
| O_CLOEXEC
| O_NOCTTY
| O_NONBLOCK
);
2514 /* not fatal; simply ignore the device */
2515 log_debug_errno(errno
, "grdrm: %s/%s: cannot open node %s: %m",
2516 basecard
->session
->name
, basecard
->name
, cu
->devnode
);
2520 /* we might already be DRM-Master by open(); that's fine */
2522 r
= grdrm_card_open(&cu
->card
, fd
);
2524 log_debug_errno(r
, "grdrm: %s/%s: cannot open: %m",
2525 basecard
->session
->name
, basecard
->name
);
2530 r
= ioctl(cu
->card
.fd
, DRM_IOCTL_SET_MASTER
, 0);
2532 log_debug_errno(errno
, "grdrm: %s/%s: cannot acquire DRM-Master: %m",
2533 basecard
->session
->name
, basecard
->name
);
2537 grdrm_card_enable(&cu
->card
);
2540 static void unmanaged_card_disable(grdev_card
*basecard
) {
2541 unmanaged_card
*cu
= unmanaged_card_from_base(basecard
);
2543 grdrm_card_disable(&cu
->card
);
2546 static int unmanaged_card_new(grdev_card
**out
, grdev_session
*session
, struct udev_device
*ud
) {
2547 _cleanup_(grdev_card_freep
) grdev_card
*basecard
= NULL
;
2548 char name
[GRDRM_CARD_NAME_MAX
];
2550 const char *devnode
;
2554 assert_return(session
, -EINVAL
);
2555 assert_return(ud
, -EINVAL
);
2557 devnode
= udev_device_get_devnode(ud
);
2558 devnum
= udev_device_get_devnum(ud
);
2559 if (!devnode
|| devnum
== 0)
2562 grdrm_name(name
, devnum
);
2564 cu
= new0(unmanaged_card
, 1);
2568 basecard
= &cu
->card
.base
;
2569 cu
->card
= GRDRM_CARD_INIT(&unmanaged_card_vtable
, session
);
2571 cu
->devnode
= strdup(devnode
);
2575 r
= grdrm_card_add(&cu
->card
, name
);
2579 /* try to open but ignore errors */
2580 fd
= open(cu
->devnode
, O_RDWR
| O_CLOEXEC
| O_NOCTTY
| O_NONBLOCK
);
2582 /* not fatal; allow uaccess based control on activation */
2583 log_debug_errno(errno
, "grdrm: %s/%s: cannot open node %s: %m",
2584 basecard
->session
->name
, basecard
->name
, cu
->devnode
);
2586 /* We might get DRM-Master implicitly on open(); drop it immediately
2587 * so we acquire it only once we're actually enabled. We don't
2588 * really care whether this call fails or not, but lets log any
2589 * weird errors, anyway. */
2590 r
= ioctl(fd
, DRM_IOCTL_DROP_MASTER
, 0);
2591 if (r
< 0 && errno
!= EACCES
&& errno
!= EINVAL
)
2592 log_debug_errno(errno
, "grdrm: %s/%s: cannot drop DRM-Master: %m",
2593 basecard
->session
->name
, basecard
->name
);
2595 r
= grdrm_card_open(&cu
->card
, fd
);
2597 log_debug_errno(r
, "grdrm: %s/%s: cannot open: %m",
2598 basecard
->session
->name
, basecard
->name
);
2607 static void unmanaged_card_free(grdev_card
*basecard
) {
2608 unmanaged_card
*cu
= unmanaged_card_from_base(basecard
);
2610 assert(!basecard
->enabled
);
2612 grdrm_card_close(&cu
->card
);
2613 grdrm_card_destroy(&cu
->card
);
2618 static const grdev_card_vtable unmanaged_card_vtable
= {
2619 .free
= unmanaged_card_free
,
2620 .enable
= unmanaged_card_enable
,
2621 .disable
= unmanaged_card_disable
,
2622 .commit
= grdrm_card_commit
,
2623 .restore
= grdrm_card_restore
,
2628 * The managed DRM card uses systemd-logind to acquire DRM devices. This
2629 * means, we do not open the device node /dev/dri/cardX directly. Instead,
2630 * logind passes us a file-descriptor whenever our session is activated. Thus,
2631 * we don't need access to the device node directly.
2632 * Furthermore, whenever the session is put asleep, logind revokes the
2633 * file-descriptor so we loose access to the device.
2634 * Managed DRM cards should be preferred over unmanaged DRM cards whenever
2635 * you run inside a user session with exclusive device access.
2638 static void managed_card_enable(grdev_card
*card
) {
2639 managed_card
*cm
= managed_card_from_base(card
);
2641 /* If the device is manually re-enabled, we try to resume our card
2642 * management. Note that we have no control over DRM-Master and the fd,
2643 * so we have to take over the state from the last logind event. */
2646 grdrm_card_enable(&cm
->card
);
2649 static void managed_card_disable(grdev_card
*card
) {
2650 managed_card
*cm
= managed_card_from_base(card
);
2652 /* If the device is manually disabled, we keep the FD but put our card
2653 * management asleep. This way, we can wake up at any time, but don't
2654 * touch the device while asleep. */
2656 grdrm_card_disable(&cm
->card
);
2659 static int managed_card_pause_device_fn(sd_bus
*bus
,
2660 sd_bus_message
*signal
,
2662 sd_bus_error
*ret_error
) {
2663 managed_card
*cm
= userdata
;
2664 grdev_session
*session
= cm
->card
.base
.session
;
2665 uint32_t major
, minor
;
2670 * We get PauseDevice() signals from logind whenever a device we
2671 * requested was, or is about to be, paused. Arguments are major/minor
2672 * number of the device and the mode of the operation.
2673 * In case the event is not about our device, we ignore it. Otherwise,
2674 * we treat it as asynchronous DRM-DROP-MASTER. Note that we might have
2675 * already handled an EACCES error from a modeset ioctl, in which case
2676 * we already disabled the device.
2678 * @mode can be one of the following:
2679 * "pause": The device is about to be paused. We must react
2680 * immediately and respond with PauseDeviceComplete(). Once
2681 * we replied, logind will pause the device. Note that
2682 * logind might apply any kind of timeout and force pause
2683 * the device if we don't respond in a timely manner. In
2684 * this case, we will receive a second PauseDevice event
2685 * with @mode set to "force" (or similar).
2686 * "force": The device was disabled forecfully by logind. DRM-Master
2687 * was already dropped. This is just an asynchronous
2688 * notification so we can put the device asleep (in case
2689 * we didn't already notice the dropped DRM-Master).
2690 * "gone": This is like "force" but is sent if the device was
2691 * paused due to a device-removal event.
2693 * We always handle PauseDevice signals as "force" as we properly
2694 * support asynchronously dropping DRM-Master, anyway. But in case
2695 * logind sent mode "pause", we also call PauseDeviceComplete() to
2696 * immediately acknowledge the request.
2699 r
= sd_bus_message_read(signal
, "uus", &major
, &minor
, &mode
);
2701 log_debug("grdrm: %s/%s: erroneous PauseDevice signal",
2702 session
->name
, cm
->card
.base
.name
);
2706 /* not our device? */
2707 if (makedev(major
, minor
) != cm
->devnum
)
2711 grdrm_card_disable(&cm
->card
);
2713 if (streq(mode
, "pause")) {
2714 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
2717 * Sending PauseDeviceComplete() is racy if logind triggers the
2718 * timeout. That is, if we take too long and logind pauses the
2719 * device by sending a forced PauseDevice, our
2720 * PauseDeviceComplete call will be stray. That's fine, though.
2721 * logind ignores such stray calls. Only if logind also sent a
2722 * further PauseDevice() signal, it might match our call
2723 * incorrectly to the newer PauseDevice(). That's fine, too, as
2724 * we handle that event asynchronously, anyway. Therefore,
2725 * whatever happens, we're fine. Yay!
2728 r
= sd_bus_message_new_method_call(session
->context
->sysbus
,
2730 "org.freedesktop.login1",
2732 "org.freedesktop.login1.Session",
2733 "PauseDeviceComplete");
2735 r
= sd_bus_message_append(m
, "uu", major
, minor
);
2737 r
= sd_bus_send(session
->context
->sysbus
, m
, NULL
);
2741 log_debug_errno(r
, "grdrm: %s/%s: cannot send PauseDeviceComplete: %m",
2742 session
->name
, cm
->card
.base
.name
);
2748 static int managed_card_resume_device_fn(sd_bus
*bus
,
2749 sd_bus_message
*signal
,
2751 sd_bus_error
*ret_error
) {
2752 managed_card
*cm
= userdata
;
2753 grdev_session
*session
= cm
->card
.base
.session
;
2754 uint32_t major
, minor
;
2758 * We get ResumeDevice signals whenever logind resumed a previously
2759 * paused device. The arguments contain the major/minor number of the
2760 * related device and a new file-descriptor for the freshly opened
2762 * If the signal is not about our device, we simply ignore it.
2763 * Otherwise, we immediately resume the device. Note that we drop the
2764 * new file-descriptor as we already have one from TakeDevice(). logind
2765 * preserves the file-context across pause/resume for DRM but only
2766 * drops/acquires DRM-Master accordingly. This way, our context (like
2767 * DRM-FBs and BOs) is preserved.
2770 r
= sd_bus_message_read(signal
, "uuh", &major
, &minor
, &fd
);
2772 log_debug("grdrm: %s/%s: erroneous ResumeDevice signal",
2773 session
->name
, cm
->card
.base
.name
);
2777 /* not our device? */
2778 if (makedev(major
, minor
) != cm
->devnum
)
2781 if (cm
->card
.fd
< 0) {
2782 /* This shouldn't happen. We should already own an FD from
2783 * TakeDevice(). However, lets be safe and use this FD in case
2784 * we really don't have one. There is no harm in doing this
2785 * and our code works fine this way. */
2786 fd
= fcntl(fd
, F_DUPFD_CLOEXEC
, 3);
2788 log_debug_errno(errno
, "grdrm: %s/%s: cannot duplicate fd: %m",
2789 session
->name
, cm
->card
.base
.name
);
2793 r
= grdrm_card_open(&cm
->card
, fd
);
2795 log_debug_errno(r
, "grdrm: %s/%s: cannot open: %m",
2796 session
->name
, cm
->card
.base
.name
);
2802 if (cm
->card
.base
.enabled
)
2803 grdrm_card_enable(&cm
->card
);
2808 static int managed_card_setup_bus(managed_card
*cm
) {
2809 grdev_session
*session
= cm
->card
.base
.session
;
2810 _cleanup_free_
char *match
= NULL
;
2813 match
= strjoin("type='signal',"
2814 "sender='org.freedesktop.login1',"
2815 "interface='org.freedesktop.login1.Session',"
2816 "member='PauseDevice',"
2817 "path='", session
->path
, "'",
2822 r
= sd_bus_add_match(session
->context
->sysbus
,
2823 &cm
->slot_pause_device
,
2825 managed_card_pause_device_fn
,
2831 match
= strjoin("type='signal',"
2832 "sender='org.freedesktop.login1',"
2833 "interface='org.freedesktop.login1.Session',"
2834 "member='ResumeDevice',"
2835 "path='", session
->path
, "'",
2840 r
= sd_bus_add_match(session
->context
->sysbus
,
2841 &cm
->slot_resume_device
,
2843 managed_card_resume_device_fn
,
2851 static int managed_card_take_device_fn(sd_bus
*bus
,
2852 sd_bus_message
*reply
,
2854 sd_bus_error
*ret_error
) {
2855 managed_card
*cm
= userdata
;
2856 grdev_session
*session
= cm
->card
.base
.session
;
2859 cm
->slot_take_device
= sd_bus_slot_unref(cm
->slot_take_device
);
2861 if (sd_bus_message_is_method_error(reply
, NULL
)) {
2862 const sd_bus_error
*error
= sd_bus_message_get_error(reply
);
2864 log_debug("grdrm: %s/%s: TakeDevice failed: %s: %s",
2865 session
->name
, cm
->card
.base
.name
, error
->name
, error
->message
);
2869 cm
->acquired
= true;
2871 r
= sd_bus_message_read(reply
, "hb", &fd
, &paused
);
2873 log_debug("grdrm: %s/%s: erroneous TakeDevice reply",
2874 session
->name
, cm
->card
.base
.name
);
2878 fd
= fcntl(fd
, F_DUPFD_CLOEXEC
, 3);
2880 log_debug_errno(errno
, "grdrm: %s/%s: cannot duplicate fd: %m",
2881 session
->name
, cm
->card
.base
.name
);
2885 r
= grdrm_card_open(&cm
->card
, fd
);
2887 log_debug_errno(r
, "grdrm: %s/%s: cannot open: %m",
2888 session
->name
, cm
->card
.base
.name
);
2892 if (!paused
&& cm
->card
.base
.enabled
)
2893 grdrm_card_enable(&cm
->card
);
2898 static void managed_card_take_device(managed_card
*cm
) {
2899 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
2900 grdev_session
*session
= cm
->card
.base
.session
;
2903 r
= sd_bus_message_new_method_call(session
->context
->sysbus
,
2905 "org.freedesktop.login1",
2907 "org.freedesktop.login1.Session",
2912 r
= sd_bus_message_append(m
, "uu", major(cm
->devnum
), minor(cm
->devnum
));
2916 r
= sd_bus_call_async(session
->context
->sysbus
,
2917 &cm
->slot_take_device
,
2919 managed_card_take_device_fn
,
2925 cm
->requested
= true;
2929 log_debug_errno(r
, "grdrm: %s/%s: cannot send TakeDevice request: %m",
2930 session
->name
, cm
->card
.base
.name
);
2933 static void managed_card_release_device(managed_card
*cm
) {
2934 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
2935 grdev_session
*session
= cm
->card
.base
.session
;
2939 * If TakeDevice() is pending or was successful, make sure to
2940 * release the device again. We don't care for return-values,
2941 * so send it without waiting or callbacks.
2942 * If a failed TakeDevice() is pending, but someone else took
2943 * the device on the same bus-connection, we might incorrectly
2944 * release their device. This is an unlikely race, though.
2945 * Furthermore, you really shouldn't have two users of the
2946 * controller-API on the same session, on the same devices, *AND* on
2947 * the same bus-connection. So we don't care for that race..
2950 grdrm_card_close(&cm
->card
);
2951 cm
->requested
= false;
2953 if (!cm
->acquired
&& !cm
->slot_take_device
)
2956 cm
->slot_take_device
= sd_bus_slot_unref(cm
->slot_take_device
);
2957 cm
->acquired
= false;
2959 r
= sd_bus_message_new_method_call(session
->context
->sysbus
,
2961 "org.freedesktop.login1",
2963 "org.freedesktop.login1.Session",
2966 r
= sd_bus_message_append(m
, "uu", major(cm
->devnum
), minor(cm
->devnum
));
2968 r
= sd_bus_send(session
->context
->sysbus
, m
, NULL
);
2971 if (r
< 0 && r
!= -ENOTCONN
)
2972 log_debug_errno(r
, "grdrm: %s/%s: cannot send ReleaseDevice: %m",
2973 session
->name
, cm
->card
.base
.name
);
2976 static int managed_card_new(grdev_card
**out
, grdev_session
*session
, struct udev_device
*ud
) {
2977 _cleanup_(grdev_card_freep
) grdev_card
*basecard
= NULL
;
2978 char name
[GRDRM_CARD_NAME_MAX
];
2983 assert_return(session
, -EINVAL
);
2984 assert_return(session
->managed
, -EINVAL
);
2985 assert_return(session
->context
->sysbus
, -EINVAL
);
2986 assert_return(ud
, -EINVAL
);
2988 devnum
= udev_device_get_devnum(ud
);
2992 grdrm_name(name
, devnum
);
2994 cm
= new0(managed_card
, 1);
2998 basecard
= &cm
->card
.base
;
2999 cm
->card
= GRDRM_CARD_INIT(&managed_card_vtable
, session
);
3000 cm
->devnum
= devnum
;
3002 r
= managed_card_setup_bus(cm
);
3006 r
= grdrm_card_add(&cm
->card
, name
);
3010 managed_card_take_device(cm
);
3018 static void managed_card_free(grdev_card
*basecard
) {
3019 managed_card
*cm
= managed_card_from_base(basecard
);
3021 assert(!basecard
->enabled
);
3023 managed_card_release_device(cm
);
3024 cm
->slot_resume_device
= sd_bus_slot_unref(cm
->slot_resume_device
);
3025 cm
->slot_pause_device
= sd_bus_slot_unref(cm
->slot_pause_device
);
3026 grdrm_card_destroy(&cm
->card
);
3030 static const grdev_card_vtable managed_card_vtable
= {
3031 .free
= managed_card_free
,
3032 .enable
= managed_card_enable
,
3033 .disable
= managed_card_disable
,
3034 .commit
= grdrm_card_commit
,
3035 .restore
= grdrm_card_restore
,
3039 * Generic Constructor
3040 * Instead of relying on the caller to choose between managed and unmanaged
3041 * DRM devices, the grdev_drm_new() constructor does that for you (by
3042 * looking at session->managed).
3045 bool grdev_is_drm_card(grdev_card
*basecard
) {
3046 return basecard
&& (basecard
->vtable
== &unmanaged_card_vtable
||
3047 basecard
->vtable
== &managed_card_vtable
);
3050 grdev_card
*grdev_find_drm_card(grdev_session
*session
, dev_t devnum
) {
3051 char name
[GRDRM_CARD_NAME_MAX
];
3053 assert_return(session
, NULL
);
3054 assert_return(devnum
!= 0, NULL
);
3056 grdrm_name(name
, devnum
);
3057 return grdev_find_card(session
, name
);
3060 int grdev_drm_card_new(grdev_card
**out
, grdev_session
*session
, struct udev_device
*ud
) {
3061 assert_return(session
, -EINVAL
);
3062 assert_return(ud
, -EINVAL
);
3064 return session
->managed
? managed_card_new(out
, session
, ud
) : unmanaged_card_new(out
, session
, ud
);
3067 void grdev_drm_card_hotplug(grdev_card
*basecard
, struct udev_device
*ud
) {
3068 const char *p
, *action
;
3073 assert(grdev_is_drm_card(basecard
));
3076 card
= grdrm_card_from_base(basecard
);
3078 action
= udev_device_get_action(ud
);
3079 if (!action
|| streq(action
, "add") || streq(action
, "remove")) {
3080 /* If we get add/remove events on DRM nodes without devnum, we
3081 * got hotplugged DRM objects so refresh the device. */
3082 devnum
= udev_device_get_devnum(ud
);
3084 card
->hotplug
= true;
3085 grdrm_card_hotplug(card
);
3087 } else if (streq_ptr(action
, "change")) {
3088 /* A change event with HOTPLUG=1 is sent whenever a connector
3089 * changed state. Refresh the device to update our state. */
3090 p
= udev_device_get_property_value(ud
, "HOTPLUG");
3091 if (streq_ptr(p
, "1")) {
3092 card
->hotplug
= true;
3093 grdrm_card_hotplug(card
);