From: Jani Nikula <jani.nikula@intel.com>
To: Gil Dekel <gildekel@google.com>, igt-dev@lists.freedesktop.org
Cc: Gil Dekel <gildekel@google.com>,
Thadeu Lima de Souza Cascardo <cascardo@igalia.com>,
Kamil Konieczny <kamil.konieczny@linux.intel.com>,
Mark Yacoub <markyacoub@google.com>
Subject: Re: [PATCH i-g-t] lib/igt_kms: Skip connectors that can't scan out
Date: Mon, 16 Nov 2026 12:09:49 +0200 [thread overview]
Message-ID: <2830247d327fd002ee4d22be4168a1f44b4f0f85@intel.com> (raw)
In-Reply-To: <20261114222855.1403127-1-gildekel@google.com>
On Sat, 14 Nov 2026, Gil Dekel <gildekel@google.com> wrote:
> igt_output_is_connected() trusts the connector status alone. Some
> drivers expose writeback outputs as always-connected
> DRM_MODE_CONNECTOR_VIRTUAL connectors next to their eDP and DP
> connectors; the downstream msm SDE driver is one.
Why do "some drivers" use DRM_MODE_CONNECTOR_VIRTUAL instead of
DRM_MODE_CONNECTOR_WRITEBACK? If they used writeback consistently, could
we handle all of this in a more clean fashion?
Are there upstream drivers that expose writeback as virtual? Or is "some
drivers" essentially a single downstream driver? Just trying to
establish what we're dealing with here, and how much cruft is being
added to cater for it. This is not a trivial amount of code for what
seems like a corner case.
> IGT then picks such
> a connector as a display. Its first modeset fails with -EINVAL because
> no writeback framebuffer is attached, and every test that calls
> igt_display_require() fails in its fixture.
>
> Commit 321448df7fc9 ("lib/igt_kms: Do not treat writeback and virtual
> connectors as connected") skipped all virtual connectors. It broke VKMS,
> which has nothing but virtual connectors, and was reverted.
>
> Add kmstest_connector_is_scanout_sink(), which decides from the uAPI
> alone:
> - Writeback connectors, and any connector exposing WRITEBACK_FB_ID,
> are never scanout sinks.
> - On devices that only expose virtual connectors (VKMS, virtio-gpu,
> vmwgfx, ...), the virtual connectors are the displays and are left
> alone.
> - Next to physical connectors, a connected virtual connector is hidden
> only if the kernel rejects a TEST_ONLY commit that lights it up with
> a plain XRGB8888 primary plane on every CRTC it can use. If the probe
> can't be sent (no atomic cap, or not DRM master), the connector is
> kept.
What's the runtime penalty of doing all this for all tests? Meaningful
hit for running CI?
> igt_display_reset_outputs() caches the result per output, and
> igt_output_is_connected() honours it. kms_setmode enumerates
> connectors itself on a legacy fd, so it enables the atomic cap just
> long enough to classify them in its fixture. kms_writeback walks
> for_each_output() and still finds its connector.
>
> Cc: Thadeu Lima de Souza Cascardo <cascardo@igalia.com>
> Cc: Kamil Konieczny <kamil.konieczny@linux.intel.com>
> Cc: Mark Yacoub <markyacoub@google.com>
> Assisted-by: Claude:claude-opus-5.5
> Signed-off-by: Gil Dekel <gildekel@google.com>
> ---
> lib/igt_kms.c | 466 ++++++++++++++++++++++++++++++++++++++++++++
> lib/igt_kms.h | 16 +-
> tests/kms_setmode.c | 39 ++++
> 3 files changed, 519 insertions(+), 2 deletions(-)
This is going to be painful for anyone to review properly. IMO the
kms_setmode change needs to be split to a separate patch. Can you find
additional ways to chop this up?
BR,
Jani.
>
> diff --git a/lib/igt_kms.c b/lib/igt_kms.c
> index 915c6a8a2..bae0f386b 100644
> --- a/lib/igt_kms.c
> +++ b/lib/igt_kms.c
> @@ -2020,6 +2020,449 @@ void igt_sort_connector_modes(drmModeConnector *connector,
> comparator);
> }
>
> +static bool connector_type_is_physical(uint32_t connector_type)
> +{
> + return connector_type != DRM_MODE_CONNECTOR_VIRTUAL &&
> + connector_type != DRM_MODE_CONNECTOR_WRITEBACK;
> +}
> +
> +static bool device_has_physical_connector(int drm_fd, const drmModeRes *res)
> +{
> + for (int i = 0; i < res->count_connectors; i++) {
> + drmModeConnector *c;
> + bool physical;
> +
> + c = drmModeGetConnectorCurrent(drm_fd, res->connectors[i]);
> + if (!c)
> + continue;
> +
> + physical = connector_type_is_physical(c->connector_type);
> + drmModeFreeConnector(c);
> +
> + if (physical)
> + return true;
> + }
> +
> + return false;
> +}
> +
> +/* Plane properties used by the scanout probe. */
> +enum probe_plane_prop {
> + PROBE_PLANE_FB_ID,
> + PROBE_PLANE_CRTC_ID,
> + PROBE_PLANE_SRC_X,
> + PROBE_PLANE_SRC_Y,
> + PROBE_PLANE_SRC_W,
> + PROBE_PLANE_SRC_H,
> + PROBE_PLANE_CRTC_X,
> + PROBE_PLANE_CRTC_Y,
> + PROBE_PLANE_CRTC_W,
> + PROBE_PLANE_CRTC_H,
> + PROBE_PLANE_TYPE,
> + PROBE_PLANE_NUM_PROPS
> +};
> +
> +static const char * const probe_plane_prop_names[PROBE_PLANE_NUM_PROPS] = {
> + [PROBE_PLANE_FB_ID] = "FB_ID",
> + [PROBE_PLANE_CRTC_ID] = "CRTC_ID",
> + [PROBE_PLANE_SRC_X] = "SRC_X",
> + [PROBE_PLANE_SRC_Y] = "SRC_Y",
> + [PROBE_PLANE_SRC_W] = "SRC_W",
> + [PROBE_PLANE_SRC_H] = "SRC_H",
> + [PROBE_PLANE_CRTC_X] = "CRTC_X",
> + [PROBE_PLANE_CRTC_Y] = "CRTC_Y",
> + [PROBE_PLANE_CRTC_W] = "CRTC_W",
> + [PROBE_PLANE_CRTC_H] = "CRTC_H",
> + [PROBE_PLANE_TYPE] = "type",
> +};
> +
> +struct probe_plane {
> + uint32_t id;
> + uint32_t possible_crtcs;
> + uint32_t props[PROBE_PLANE_NUM_PROPS];
> + uint64_t values[PROBE_PLANE_NUM_PROPS];
> +};
> +
> +struct probe_connector {
> + uint32_t id;
> + uint32_t crtc_id_prop;
> + uint64_t crtc_id;
> +};
> +
> +struct scanout_probe {
> + int drm_fd;
> + const drmModeConnector *connector;
> + uint32_t conn_crtc_id_prop;
> + const drmModeModeInfo *mode;
> + uint32_t mode_blob;
> + uint32_t fb_id;
> + struct probe_connector *others;
> + int n_others;
> + struct probe_plane *planes;
> + int n_planes;
> +};
> +
> +/* Looks up the ids and current values of @n named properties of an object. */
> +static bool probe_lookup_props(int drm_fd, uint32_t obj_id, uint32_t obj_type,
> + const char * const names[], int n,
> + uint32_t ids[], uint64_t values[])
> +{
> + drmModeObjectPropertiesPtr props;
> + int found = 0;
> +
> + props = drmModeObjectGetProperties(drm_fd, obj_id, obj_type);
> + if (!props)
> + return false;
> +
> + for (int i = 0; i < props->count_props; i++) {
> + drmModePropertyPtr prop = drmModeGetProperty(drm_fd, props->props[i]);
> +
> + if (!prop)
> + continue;
> +
> + for (int j = 0; j < n; j++) {
> + if (strcmp(prop->name, names[j]))
> + continue;
> +
> + ids[j] = props->props[i];
> + values[j] = props->prop_values[i];
> + found++;
> + break;
> + }
> +
> + drmModeFreeProperty(prop);
> + }
> +
> + drmModeFreeObjectProperties(props);
> +
> + return found == n;
> +}
> +
> +static void probe_add(drmModeAtomicReq *req, uint32_t obj_id,
> + uint32_t prop_id, uint64_t value)
> +{
> + igt_assert_lte(0, drmModeAtomicAddProperty(req, obj_id, prop_id, value));
> +}
> +
> +/* Returns an XRGB8888 dumb framebuffer id for @mode, or 0 on failure. */
> +static uint32_t probe_fb_create(int drm_fd, const drmModeModeInfo *mode,
> + uint32_t *handle)
> +{
> + struct drm_mode_create_dumb create = {
> + .width = mode->hdisplay,
> + .height = mode->vdisplay,
> + .bpp = 32,
> + };
> + uint32_t handles[4] = { 0 }, pitches[4] = { 0 }, offsets[4] = { 0 };
> + uint32_t fb_id = 0;
> +
> + *handle = 0;
> +
> + /* The buffer is never mapped, so its pages are never allocated. */
> + if (drmIoctl(drm_fd, DRM_IOCTL_MODE_CREATE_DUMB, &create))
> + return 0;
> +
> + handles[0] = create.handle;
> + pitches[0] = create.pitch;
> + if (drmModeAddFB2(drm_fd, mode->hdisplay, mode->vdisplay,
> + DRM_FORMAT_XRGB8888, handles, pitches, offsets,
> + &fb_id, 0)) {
> + __kmstest_dumb_destroy(drm_fd, create.handle);
> + return 0;
> + }
> +
> + *handle = create.handle;
> +
> + return fb_id;
> +}
> +
> +/*
> + * TEST_ONLY commit that lights up the probed connector on @crtc_id with
> + * the probe mode and, if available, the probe fb on a primary plane.
> + * Other connectors and planes on that CRTC are detached in the same
> + * request. No writeback framebuffer is attached.
> + */
> +static int probe_scanout_on_crtc(const struct scanout_probe *p,
> + uint32_t crtc_id, int crtc_idx)
> +{
> + static const char * const crtc_prop_names[] = { "MODE_ID", "ACTIVE" };
> + uint32_t crtc_props[2];
> + uint64_t crtc_values[2];
> + bool have_primary = false;
> + drmModeAtomicReq *req;
> + int ret;
> +
> + if (!probe_lookup_props(p->drm_fd, crtc_id, DRM_MODE_OBJECT_CRTC,
> + crtc_prop_names, 2, crtc_props, crtc_values))
> + return -EOPNOTSUPP;
> +
> + req = drmModeAtomicAlloc();
> + igt_assert(req);
> +
> + probe_add(req, crtc_id, crtc_props[0], p->mode_blob);
> + probe_add(req, crtc_id, crtc_props[1], 1);
> + probe_add(req, p->connector->connector_id, p->conn_crtc_id_prop,
> + crtc_id);
> +
> + for (int i = 0; i < p->n_others; i++)
> + if (p->others[i].crtc_id == crtc_id)
> + probe_add(req, p->others[i].id,
> + p->others[i].crtc_id_prop, 0);
> +
> + for (int i = 0; i < p->n_planes; i++) {
> + const struct probe_plane *plane = &p->planes[i];
> + const uint32_t *props = plane->props;
> + const drmModeModeInfo *mode = p->mode;
> +
> + if (p->fb_id && !have_primary &&
> + plane->possible_crtcs & (1u << crtc_idx) &&
> + plane->values[PROBE_PLANE_TYPE] == DRM_PLANE_TYPE_PRIMARY) {
> + probe_add(req, plane->id, props[PROBE_PLANE_FB_ID],
> + p->fb_id);
> + probe_add(req, plane->id, props[PROBE_PLANE_CRTC_ID],
> + crtc_id);
> + probe_add(req, plane->id, props[PROBE_PLANE_SRC_X], 0);
> + probe_add(req, plane->id, props[PROBE_PLANE_SRC_Y], 0);
> + probe_add(req, plane->id, props[PROBE_PLANE_SRC_W],
> + (uint64_t)mode->hdisplay << 16);
> + probe_add(req, plane->id, props[PROBE_PLANE_SRC_H],
> + (uint64_t)mode->vdisplay << 16);
> + probe_add(req, plane->id, props[PROBE_PLANE_CRTC_X], 0);
> + probe_add(req, plane->id, props[PROBE_PLANE_CRTC_Y], 0);
> + probe_add(req, plane->id, props[PROBE_PLANE_CRTC_W],
> + mode->hdisplay);
> + probe_add(req, plane->id, props[PROBE_PLANE_CRTC_H],
> + mode->vdisplay);
> + have_primary = true;
> + } else if (plane->values[PROBE_PLANE_CRTC_ID] == crtc_id) {
> + probe_add(req, plane->id, props[PROBE_PLANE_FB_ID], 0);
> + probe_add(req, plane->id, props[PROBE_PLANE_CRTC_ID], 0);
> + }
> + }
> +
> + ret = drmModeAtomicCommit(p->drm_fd, req,
> + DRM_MODE_ATOMIC_TEST_ONLY |
> + DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
> + drmModeAtomicFree(req);
> +
> + return ret;
> +}
> +
> +/*
> + * Asks the kernel, with TEST_ONLY commits on each possible CRTC, whether
> + * @connector can be lit up as a display without a writeback framebuffer.
> + *
> + * Returns 0 if a CRTC accepts it, otherwise the last error. -ENOENT,
> + * -EOPNOTSUPP and -EACCES mean no probe reached the atomic check:
> + * @connector is disconnected, @drm_fd lacks the atomic client cap
> + * (atomic properties are hidden), or @drm_fd is not DRM master.
> + */
> +static int probe_scanout_sink(int drm_fd, const drmModeRes *res,
> + const drmModeConnector *connector)
> +{
> + struct scanout_probe p = { .drm_fd = drm_fd, .connector = connector };
> + drmModePlaneRes *plane_res;
> + uint32_t possible_crtcs = 0, handle;
> + int ret = -ENODEV;
> +
> + if (connector->connection != DRM_MODE_CONNECTED ||
> + !connector->count_modes)
> + return -ENOENT;
> +
> + if (!kmstest_get_property(drm_fd, connector->connector_id,
> + DRM_MODE_OBJECT_CONNECTOR, "CRTC_ID",
> + &p.conn_crtc_id_prop, NULL, NULL))
> + return -EOPNOTSUPP;
> +
> + for (int i = 0; i < connector->count_encoders; i++) {
> + drmModeEncoder *encoder;
> +
> + encoder = drmModeGetEncoder(drm_fd, connector->encoders[i]);
> + if (!encoder)
> + continue;
> +
> + possible_crtcs |= encoder->possible_crtcs;
> + drmModeFreeEncoder(encoder);
> + }
> +
> + /* The smallest mode keeps the probe framebuffer small. */
> + p.mode = &connector->modes[0];
> + for (int i = 1; i < connector->count_modes; i++) {
> + const drmModeModeInfo *m = &connector->modes[i];
> +
> + if (m->hdisplay * m->vdisplay <
> + p.mode->hdisplay * p.mode->vdisplay)
> + p.mode = m;
> + }
> +
> + p.others = calloc(res->count_connectors, sizeof(*p.others));
> + igt_assert(p.others);
> + for (int i = 0; i < res->count_connectors; i++) {
> + struct probe_connector *other = &p.others[p.n_others];
> +
> + if (res->connectors[i] == connector->connector_id)
> + continue;
> +
> + if (kmstest_get_property(drm_fd, res->connectors[i],
> + DRM_MODE_OBJECT_CONNECTOR, "CRTC_ID",
> + &other->crtc_id_prop, &other->crtc_id,
> + NULL)) {
> + other->id = res->connectors[i];
> + p.n_others++;
> + }
> + }
> +
> + plane_res = drmModeGetPlaneResources(drm_fd);
> + if (plane_res && plane_res->count_planes) {
> + p.planes = calloc(plane_res->count_planes, sizeof(*p.planes));
> + igt_assert(p.planes);
> + }
> + for (int i = 0; p.planes && i < plane_res->count_planes; i++) {
> + struct probe_plane *plane = &p.planes[p.n_planes];
> + drmModePlane *drm_plane;
> +
> + drm_plane = drmModeGetPlane(drm_fd, plane_res->planes[i]);
> + if (!drm_plane)
> + continue;
> +
> + plane->id = drm_plane->plane_id;
> + plane->possible_crtcs = drm_plane->possible_crtcs;
> + drmModeFreePlane(drm_plane);
> +
> + if (probe_lookup_props(drm_fd, plane->id, DRM_MODE_OBJECT_PLANE,
> + probe_plane_prop_names,
> + PROBE_PLANE_NUM_PROPS, plane->props,
> + plane->values))
> + p.n_planes++;
> + }
> + drmModeFreePlaneResources(plane_res);
> +
> + ret = drmModeCreatePropertyBlob(drm_fd, p.mode, sizeof(*p.mode),
> + &p.mode_blob);
> + if (ret)
> + goto out;
> +
> + /* Without an fb, still probe with the CRTC and connector alone. */
> + p.fb_id = probe_fb_create(drm_fd, p.mode, &handle);
> +
> + ret = -ENODEV;
> + for (int i = 0; i < res->count_crtcs && i < 32; i++) {
> + if (!(possible_crtcs & (1u << i)))
> + continue;
> +
> + ret = probe_scanout_on_crtc(&p, res->crtcs[i], i);
> + if (!ret)
> + break;
> + }
> +
> + if (p.fb_id) {
> + drmModeRmFB(drm_fd, p.fb_id);
> + __kmstest_dumb_destroy(drm_fd, handle);
> + }
> + drmModeDestroyPropertyBlob(drm_fd, p.mode_blob);
> +out:
> + free(p.planes);
> + free(p.others);
> +
> + return ret;
> +}
> +
> +static const char *probe_result_str(int ret)
> +{
> + switch (ret) {
> + case -ENOENT:
> + return "disconnected";
> + case -EOPNOTSUPP:
> + return "no atomic client cap";
> + case -EACCES:
> + return "not DRM master";
> + default:
> + return strerror(-ret);
> + }
> +}
> +
> +/* True if @ret means no probe reached the atomic check. */
> +static bool probe_inconclusive(int ret)
> +{
> + return ret == -ENOENT || ret == -EOPNOTSUPP || ret == -EACCES;
> +}
> +
> +static bool connector_is_scanout_sink(int drm_fd, const drmModeRes *res,
> + const drmModeConnector *connector,
> + bool has_writeback_fb_id)
> +{
> + int ret;
> +
> + if (connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK ||
> + has_writeback_fb_id)
> + return false;
> +
> + if (connector->connector_type != DRM_MODE_CONNECTOR_VIRTUAL)
> + return true;
> +
> + /* On virtual-only devices (VKMS, virtio-gpu, ...) these are the displays. */
> + if (!device_has_physical_connector(drm_fd, res))
> + return true;
> +
> + /*
> + * Next to physical connectors, a virtual connector may be a
> + * writeback or concurrent writeback sink that rejects any commit
> + * without an output fb. Only hide it when the kernel says so.
> + */
> + ret = probe_scanout_sink(drm_fd, res, connector);
> + if (!ret)
> + return true;
> +
> + if (probe_inconclusive(ret)) {
> + igt_debug("%s-%d: scanout probe not sent (%s), assuming a scanout sink\n",
> + kmstest_connector_type_str(connector->connector_type),
> + connector->connector_type_id, probe_result_str(ret));
> + return true;
> + }
> +
> + igt_debug("%s-%d: kernel rejected a plain modeset (%s), not a scanout sink\n",
> + kmstest_connector_type_str(connector->connector_type),
> + connector->connector_type_id, probe_result_str(ret));
> +
> + return false;
> +}
> +
> +/**
> + * kmstest_connector_is_scanout_sink:
> + * @drm_fd: DRM fd
> + * @res: libdrm resources of @drm_fd
> + * @connector: libdrm connector to check
> + *
> + * Checks whether @connector drives a display that can be lit up with a
> + * plain modeset, as opposed to a memory sink that needs an output
> + * framebuffer on every commit.
> + *
> + * Writeback connectors, and any connector that exposes WRITEBACK_FB_ID,
> + * are never scanout sinks. Physical connectors always are.
> + *
> + * Virtual connectors are scanout sinks on devices that only expose
> + * virtual connectors (VKMS, virtio-gpu, vmwgfx, ...). Next to physical
> + * connectors, where some drivers use them for writeback outputs, a
> + * connected virtual connector is not a scanout sink if the kernel
> + * rejects a TEST_ONLY commit that lights it up with a plain primary
> + * plane on any of its CRTCs. That probe needs DRM master and the atomic
> + * client cap on @drm_fd. Without them the connector is assumed to be a
> + * scanout sink. This function never changes the client caps of @drm_fd.
> + *
> + * Returns: True if @connector is a scanout sink, false otherwise.
> + */
> +bool kmstest_connector_is_scanout_sink(int drm_fd, const drmModeRes *res,
> + const drmModeConnector *connector)
> +{
> + bool has_writeback_fb_id =
> + kmstest_get_property(drm_fd, connector->connector_id,
> + DRM_MODE_OBJECT_CONNECTOR,
> + "WRITEBACK_FB_ID", NULL, NULL, NULL);
> +
> + return connector_is_scanout_sink(drm_fd, res, connector,
> + has_writeback_fb_id);
> +}
> +
> /**
> * kmstest_get_connector_default_mode:
> * @drm_fd: DRM fd
> @@ -2943,6 +3386,29 @@ void igt_display_reset_outputs(igt_display_t *display)
> }
> }
>
> + /*
> + * Must be known before the first igt_output_is_connected() call
> + * below, which skips outputs that aren't scanout sinks.
> + */
> + for (i = 0; i < display->n_outputs; i++) {
> + igt_output_t *output = &display->outputs[i];
See for_each_output().
> + drmModeConnector *connector = output->config.connector;
> +
> + if (!connector)
> + continue;
> +
> + output->non_scanout_sink =
> + !connector_is_scanout_sink(display->drm_fd, resources,
> + connector,
> + output->props[IGT_CONNECTOR_WRITEBACK_FB_ID]);
> +
> + if (output->non_scanout_sink &&
> + connector->connector_type == DRM_MODE_CONNECTOR_VIRTUAL &&
> + connector->connection == DRM_MODE_CONNECTED)
> + igt_info("%s: not a scanout sink, not used as a display\n",
> + output->name);
> + }
> +
> /* Set reasonable default values for every object in the
> * display. */
> igt_display_reset(display);
> diff --git a/lib/igt_kms.h b/lib/igt_kms.h
> index dfcb91e02..ac28a576e 100644
> --- a/lib/igt_kms.h
> +++ b/lib/igt_kms.h
> @@ -285,6 +285,8 @@ bool kmstest_probe_connector_config(int drm_fd, uint32_t connector_id,
> unsigned long crtc_idx_mask,
> struct kmstest_connector_config *config);
> void kmstest_free_connector_config(struct kmstest_connector_config *config);
> +bool kmstest_connector_is_scanout_sink(int drm_fd, const drmModeRes *res,
> + const drmModeConnector *connector);
>
> void kmstest_set_connector_dpms(int fd, drmModeConnector *connector, int mode);
> bool kmstest_get_property(int drm_fd, uint32_t object_id, uint32_t object_type,
> @@ -512,6 +514,8 @@ typedef struct {
> struct kmstest_connector_config config;
> char *name;
> bool force_reprobe;
> + /* Set by igt_display_reset_outputs(), see kmstest_connector_is_scanout_sink(). */
> + bool non_scanout_sink;
> igt_crtc_t *pending_crtc;
> bool use_override_mode;
> drmModeModeInfo override_mode;
> @@ -668,8 +672,12 @@ void igt_wait_for_vblank_ts_seq(igt_crtc_t *crtc, uint64_t *ts_ns, unsigned int
> * igt_output_is_connected:
> * @output: #igt_output_t to check.
> *
> - * Returns: True if given @output's connection status is CONNECTED,
> - * else False.
> + * Outputs that aren't scanout sinks (writeback connectors, and virtual
> + * connectors used as writeback outputs) are never reported as
> + * connected, see kmstest_connector_is_scanout_sink().
> + *
> + * Returns: True if given @output is a scanout sink whose connection
> + * status is CONNECTED, else False.
> */
> static inline bool igt_output_is_connected(igt_output_t *output)
> {
> @@ -678,6 +686,10 @@ static inline bool igt_output_is_connected(igt_output_t *output)
> !output->config.connector->count_modes)
> return false;
>
> + /* Memory sinks need an output fb and can't be lit up with a modeset. */
> + if (output->non_scanout_sink)
> + return false;
> +
> if (output->config.connector->connection == DRM_MODE_CONNECTED)
> return true;
>
> diff --git a/tests/kms_setmode.c b/tests/kms_setmode.c
> index a65ea8b23..f105a6ad1 100644
> --- a/tests/kms_setmode.c
> +++ b/tests/kms_setmode.c
> @@ -92,6 +92,7 @@
>
> static int drm_fd;
> static drmModeRes *drm_resources;
> +static bool *non_scanout_sink;
> static int filter_test_id;
> static bool dry_run;
> static bool extended = false;
> @@ -895,6 +896,9 @@ static int get_connectors(drmModeRes *resources, int *connector_idxs,
> igt_assert_lt(connector_idx, resources->count_connectors);
> connector_id = resources->connectors[connector_idx];
>
> + if (non_scanout_sink[connector_idx])
> + goto err;
> +
> if (get_one_connector(resources, connector_id, &cconfs[i]) < 0)
> goto err;
>
> @@ -1047,6 +1051,38 @@ static void restore_cpu_deep_sleep_at_exit(int sig)
> igt_pm_enable_cpu_deep_sleep();
> }
>
> +/*
> + * Marks the connectors that can't be lit up with a plain modeset, such
> + * as writeback outputs exposed as virtual connectors. Probing those
> + * needs the atomic cap, so enable it only here: every modeset in this
> + * test stays legacy.
> + */
> +static void find_non_scanout_sinks(void)
> +{
> + bool atomic = !drmSetClientCap(drm_fd, DRM_CLIENT_CAP_ATOMIC, 1);
> +
> + non_scanout_sink = calloc(drm_resources->count_connectors,
> + sizeof(*non_scanout_sink));
> + igt_assert(non_scanout_sink);
> +
> + for (int i = 0; i < drm_resources->count_connectors; i++) {
> + drmModeConnector *connector;
> +
> + connector = drmModeGetConnector(drm_fd,
> + drm_resources->connectors[i]);
> + if (!connector)
> + continue;
> +
> + non_scanout_sink[i] =
> + !kmstest_connector_is_scanout_sink(drm_fd, drm_resources,
> + connector);
> + drmModeFreeConnector(connector);
> + }
> +
> + if (atomic)
> + igt_assert_eq(drmSetClientCap(drm_fd, DRM_CLIENT_CAP_ATOMIC, 0), 0);
> +}
> +
> static int opt_handler(int opt, int opt_index, void *data)
> {
> switch (opt) {
> @@ -1103,6 +1139,8 @@ int igt_main_args("det:", NULL, help_str, opt_handler, NULL)
> drm_resources = drmModeGetResources(drm_fd);
> igt_require(drm_resources);
>
> + find_non_scanout_sinks();
> +
> max_dotclock = igt_get_max_dotclock(drm_fd);
> }
>
> @@ -1143,6 +1181,7 @@ int igt_main_args("det:", NULL, help_str, opt_handler, NULL)
> }
>
> igt_fixture() {
> + free(non_scanout_sink);
> drmModeFreeResources(drm_resources);
> drm_close_driver(drm_fd);
> }
--
Jani Nikula, Intel
next prev parent reply other threads:[~2026-11-16 10:11 UTC|newest]
Thread overview: 8+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-14 22:28 [PATCH i-g-t] lib/igt_kms: Skip connectors that can't scan out Gil Dekel
2026-11-15 0:18 ` [PATCH i-g-t v2] " Gil Dekel
2026-11-16 6:08 ` ✓ Xe.CI.BAT: success for lib/igt_kms: Skip connectors that can't scan out (rev2) Patchwork
2026-11-16 6:28 ` ✓ i915.CI.BAT: " Patchwork
2026-11-16 7:39 ` ✓ Xe.CI.FULL: " Patchwork
2026-11-16 9:01 ` ✗ i915.CI.Full: failure " Patchwork
2026-11-16 10:09 ` Jani Nikula [this message]
2026-11-17 3:13 ` [PATCH i-g-t] lib/igt_kms: Skip connectors that can't scan out Gil Dekel
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=2830247d327fd002ee4d22be4168a1f44b4f0f85@intel.com \
--to=jani.nikula@intel.com \
--cc=cascardo@igalia.com \
--cc=gildekel@google.com \
--cc=igt-dev@lists.freedesktop.org \
--cc=kamil.konieczny@linux.intel.com \
--cc=markyacoub@google.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox