[PATCH v6 0/6] drm: Add support for atomic async page-flip

[PATCH v6 0/6] drm: Add support for atomic async page-flip

[André Almeida]

Hi,

This work from me and Simon adds support for DRM_MODE_PAGE_FLIP_ASYNC through
the atomic API. This feature is already available via the legacy API. The use
case is to be able to present a new frame immediately (or as soon as
possible), even if after missing a vblank. This might result in tearing, but
it's useful when a high framerate is desired, such as for gaming.

Differently from earlier versions, this one refuses to flip if any prop changes
for async flips. The idea is that the fast path of immediate page flips doesn't
play well with modeset changes, so only the fb_id can be changed. The exception
is for mode_id changes, that might be referring to an identical mode (which
would skip a modeset). This is done to make the async API more similar to the
normal API.

Thanks,
	André

- User-space patch: https://github.com/Plagman/gamescope/pull/595
- IGT tests: https://gitlab.freedesktop.org/andrealmeid/igt-gpu-tools/-/tree/atomic_async_page_flip

Changes from v5:
- Add note in the docs that not every redundant attribute will result in no-op,
  some might cause oversynchronization issues.

v5: https://lore.kernel.org/dri-devel/20230707224059.305474-1-andrealmeid@igalia.com/

Changes from v4:
 - Documentation rewrote by Pekka Paalanen

v4: https://lore.kernel.org/dri-devel/20230701020917.143394-1-andrealmeid@igalia.com/

Changes from v3:
 - Add new patch to reject prop changes
 - Add a documentation clarifying the KMS atomic state set

v3: https://lore.kernel.org/dri-devel/20220929184307.258331-1-contact@emersion.fr/

André Almeida (1):
  drm: Refuse to async flip with atomic prop changes

Pekka Paalanen (1):
  drm/doc: Define KMS atomic state set

Simon Ser (4):
  drm: allow DRM_MODE_PAGE_FLIP_ASYNC for atomic commits
  drm: introduce DRM_CAP_ATOMIC_ASYNC_PAGE_FLIP
  drm: introduce drm_mode_config.atomic_async_page_flip_not_supported
  amd/display: indicate support for atomic async page-flips on DC

 Documentation/gpu/drm-uapi.rst                | 44 ++++++++++
 drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c  |  1 +
 drivers/gpu/drm/drm_atomic_helper.c           |  5 ++
 drivers/gpu/drm/drm_atomic_uapi.c             | 80 +++++++++++++++++--
 drivers/gpu/drm/drm_crtc_internal.h           |  2 +-
 drivers/gpu/drm/drm_ioctl.c                   |  5 ++
 drivers/gpu/drm/drm_mode_object.c             |  2 +-
 .../drm/i915/display/intel_display_driver.c   |  1 +
 drivers/gpu/drm/nouveau/nouveau_display.c     |  1 +
 include/drm/drm_mode_config.h                 | 11 +++
 include/uapi/drm/drm.h                        | 10 ++-
 include/uapi/drm/drm_mode.h                   |  9 +++
 12 files changed, 162 insertions(+), 9 deletions(-)

-- 
2.41.0

[PATCH v6 1/6] drm: allow DRM_MODE_PAGE_FLIP_ASYNC for atomic commits

[André Almeida]

From: Simon Ser <contact@emersion.fr>

If the driver supports it, allow user-space to supply the
DRM_MODE_PAGE_FLIP_ASYNC flag to request an async page-flip.
Set drm_crtc_state.async_flip accordingly.

Document that drivers will reject atomic commits if an async
flip isn't possible. This allows user-space to fall back to
something else. For instance, Xorg falls back to a blit.
Another option is to wait as close to the next vblank as
possible before performing the page-flip to reduce latency.

Signed-off-by: Simon Ser <contact@emersion.fr>
Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
Co-developed-by: André Almeida <andrealmeid@igalia.com>
Signed-off-by: André Almeida <andrealmeid@igalia.com>
---
v5: no changes
v4: no changes
---
 drivers/gpu/drm/drm_atomic_uapi.c | 28 +++++++++++++++++++++++++---
 include/uapi/drm/drm_mode.h       |  9 +++++++++
 2 files changed, 34 insertions(+), 3 deletions(-)

diff --git a/drivers/gpu/drm/drm_atomic_uapi.c b/drivers/gpu/drm/drm_atomic_uapi.c
index 98d3b10c08ae..a15121e75a0a 100644
--- a/drivers/gpu/drm/drm_atomic_uapi.c
+++ b/drivers/gpu/drm/drm_atomic_uapi.c
@@ -1323,6 +1323,18 @@ static void complete_signaling(struct drm_device *dev,
 	kfree(fence_state);
 }
 
+static void
+set_async_flip(struct drm_atomic_state *state)
+{
+	struct drm_crtc *crtc;
+	struct drm_crtc_state *crtc_state;
+	int i;
+
+	for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
+		crtc_state->async_flip = true;
+	}
+}
+
 int drm_mode_atomic_ioctl(struct drm_device *dev,
 			  void *data, struct drm_file *file_priv)
 {
@@ -1363,9 +1375,16 @@ int drm_mode_atomic_ioctl(struct drm_device *dev,
 	}
 
 	if (arg->flags & DRM_MODE_PAGE_FLIP_ASYNC) {
-		drm_dbg_atomic(dev,
-			       "commit failed: invalid flag DRM_MODE_PAGE_FLIP_ASYNC\n");
-		return -EINVAL;
+		if (!dev->mode_config.async_page_flip) {
+			drm_dbg_atomic(dev,
+				       "commit failed: DRM_MODE_PAGE_FLIP_ASYNC not supported\n");
+			return -EINVAL;
+		}
+		if (dev->mode_config.atomic_async_page_flip_not_supported) {
+			drm_dbg_atomic(dev,
+				       "commit failed: DRM_MODE_PAGE_FLIP_ASYNC not supported with atomic\n");
+			return -EINVAL;
+		}
 	}
 
 	/* can't test and expect an event at the same time. */
@@ -1468,6 +1487,9 @@ int drm_mode_atomic_ioctl(struct drm_device *dev,
 	if (ret)
 		goto out;
 
+	if (arg->flags & DRM_MODE_PAGE_FLIP_ASYNC)
+		set_async_flip(state);
+
 	if (arg->flags & DRM_MODE_ATOMIC_TEST_ONLY) {
 		ret = drm_atomic_check_only(state);
 	} else if (arg->flags & DRM_MODE_ATOMIC_NONBLOCK) {
diff --git a/include/uapi/drm/drm_mode.h b/include/uapi/drm/drm_mode.h
index ea1b639bcb28..04e6a3caa675 100644
--- a/include/uapi/drm/drm_mode.h
+++ b/include/uapi/drm/drm_mode.h
@@ -957,6 +957,15 @@ struct hdr_output_metadata {
  * Request that the page-flip is performed as soon as possible, ie. with no
  * delay due to waiting for vblank. This may cause tearing to be visible on
  * the screen.
+ *
+ * When used with atomic uAPI, the driver will return an error if the hardware
+ * doesn't support performing an asynchronous page-flip for this update.
+ * User-space should handle this, e.g. by falling back to a regular page-flip.
+ *
+ * Note, some hardware might need to perform one last synchronous page-flip
+ * before being able to switch to asynchronous page-flips. As an exception,
+ * the driver will return success even though that first page-flip is not
+ * asynchronous.
  */
 #define DRM_MODE_PAGE_FLIP_ASYNC 0x02
 #define DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE 0x4
-- 
2.41.0

[PATCH v6 2/6] drm: introduce DRM_CAP_ATOMIC_ASYNC_PAGE_FLIP

[André Almeida]

From: Simon Ser <contact@emersion.fr>

This new kernel capability indicates whether async page-flips are
supported via the atomic uAPI. DRM clients can use it to check
for support before feeding DRM_MODE_PAGE_FLIP_ASYNC to the kernel.

Make it clear that DRM_CAP_ASYNC_PAGE_FLIP is for legacy uAPI only.

Signed-off-by: Simon Ser <contact@emersion.fr>
Reviewed-by: André Almeida <andrealmeid@igalia.com>
Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
Signed-off-by: André Almeida <andrealmeid@igalia.com>
---
v5: no changes
v4: no changes
---
 drivers/gpu/drm/drm_ioctl.c |  5 +++++
 include/uapi/drm/drm.h      | 10 +++++++++-
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/drivers/gpu/drm/drm_ioctl.c b/drivers/gpu/drm/drm_ioctl.c
index f03ffbacfe9b..3562b717b74f 100644
--- a/drivers/gpu/drm/drm_ioctl.c
+++ b/drivers/gpu/drm/drm_ioctl.c
@@ -301,6 +301,11 @@ static int drm_getcap(struct drm_device *dev, void *data, struct drm_file *file_
 	case DRM_CAP_CRTC_IN_VBLANK_EVENT:
 		req->value = 1;
 		break;
+	case DRM_CAP_ATOMIC_ASYNC_PAGE_FLIP:
+		req->value = drm_core_check_feature(dev, DRIVER_ATOMIC) &&
+			     dev->mode_config.async_page_flip &&
+			     !dev->mode_config.atomic_async_page_flip_not_supported;
+		break;
 	default:
 		return -EINVAL;
 	}
diff --git a/include/uapi/drm/drm.h b/include/uapi/drm/drm.h
index 794c1d857677..58baefe32c23 100644
--- a/include/uapi/drm/drm.h
+++ b/include/uapi/drm/drm.h
@@ -713,7 +713,8 @@ struct drm_gem_open {
 /**
  * DRM_CAP_ASYNC_PAGE_FLIP
  *
- * If set to 1, the driver supports &DRM_MODE_PAGE_FLIP_ASYNC.
+ * If set to 1, the driver supports &DRM_MODE_PAGE_FLIP_ASYNC for legacy
+ * page-flips.
  */
 #define DRM_CAP_ASYNC_PAGE_FLIP		0x7
 /**
@@ -773,6 +774,13 @@ struct drm_gem_open {
  * :ref:`drm_sync_objects`.
  */
 #define DRM_CAP_SYNCOBJ_TIMELINE	0x14
+/**
+ * DRM_CAP_ATOMIC_ASYNC_PAGE_FLIP
+ *
+ * If set to 1, the driver supports &DRM_MODE_PAGE_FLIP_ASYNC for atomic
+ * commits.
+ */
+#define DRM_CAP_ATOMIC_ASYNC_PAGE_FLIP	0x15
 
 /* DRM_IOCTL_GET_CAP ioctl argument type */
 struct drm_get_cap {
-- 
2.41.0

[PATCH v6 3/6] drm: introduce drm_mode_config.atomic_async_page_flip_not_supported

[André Almeida]

From: Simon Ser <contact@emersion.fr>

This new field indicates whether the driver has the necessary logic
to support async page-flips via the atomic uAPI. This is leveraged by
the next commit to allow user-space to use this functionality.

All atomic drivers setting drm_mode_config.async_page_flip are updated
to also set drm_mode_config.atomic_async_page_flip_not_supported. We
will gradually check and update these drivers to properly handle
drm_crtc_state.async_flip in their atomic logic.

The goal of this negative flag is the same as
fb_modifiers_not_supported: we want to eventually get rid of all
drivers missing atomic support for async flips. New drivers should not
set this flag, instead they should support atomic async flips (if
they support async flips at all). IOW, we don't want more drivers
with async flip support for legacy but not atomic.

Signed-off-by: Simon Ser <contact@emersion.fr>
Reviewed-by: André Almeida <andrealmeid@igalia.com>
Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
Signed-off-by: André Almeida <andrealmeid@igalia.com>
---
v5: no changes
v4: no changes
---
 drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c   |  1 +
 drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c        |  1 +
 drivers/gpu/drm/i915/display/intel_display_driver.c |  1 +
 drivers/gpu/drm/nouveau/nouveau_display.c           |  1 +
 include/drm/drm_mode_config.h                       | 11 +++++++++++
 5 files changed, 15 insertions(+)

diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
index 4d3d6009838c..4b433793f5a0 100644
--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
+++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
@@ -3924,6 +3924,7 @@ static int amdgpu_dm_mode_config_init(struct amdgpu_device *adev)
 		adev_to_drm(adev)->mode_config.prefer_shadow = 1;
 	/* indicates support for immediate flip */
 	adev_to_drm(adev)->mode_config.async_page_flip = true;
+	adev_to_drm(adev)->mode_config.atomic_async_page_flip_not_supported = true;
 
 	state = kzalloc(sizeof(*state), GFP_KERNEL);
 	if (!state)
diff --git a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c
index fa0f9a93d50d..301b222c410d 100644
--- a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c
+++ b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_dc.c
@@ -639,6 +639,7 @@ static int atmel_hlcdc_dc_modeset_init(struct drm_device *dev)
 	dev->mode_config.max_height = dc->desc->max_height;
 	dev->mode_config.funcs = &mode_config_funcs;
 	dev->mode_config.async_page_flip = true;
+	dev->mode_config.atomic_async_page_flip_not_supported = true;
 
 	return 0;
 }
diff --git a/drivers/gpu/drm/i915/display/intel_display_driver.c b/drivers/gpu/drm/i915/display/intel_display_driver.c
index 8f144d4d3c39..f290c5c2e3c9 100644
--- a/drivers/gpu/drm/i915/display/intel_display_driver.c
+++ b/drivers/gpu/drm/i915/display/intel_display_driver.c
@@ -123,6 +123,7 @@ static void intel_mode_config_init(struct drm_i915_private *i915)
 	mode_config->helper_private = &intel_mode_config_funcs;
 
 	mode_config->async_page_flip = HAS_ASYNC_FLIPS(i915);
+	mode_config->atomic_async_page_flip_not_supported = true;
 
 	/*
 	 * Maximum framebuffer dimensions, chosen to match
diff --git a/drivers/gpu/drm/nouveau/nouveau_display.c b/drivers/gpu/drm/nouveau/nouveau_display.c
index 99977e5fe716..540895dabfc7 100644
--- a/drivers/gpu/drm/nouveau/nouveau_display.c
+++ b/drivers/gpu/drm/nouveau/nouveau_display.c
@@ -720,6 +720,7 @@ nouveau_display_create(struct drm_device *dev)
 		dev->mode_config.async_page_flip = false;
 	else
 		dev->mode_config.async_page_flip = true;
+	dev->mode_config.atomic_async_page_flip_not_supported = true;
 
 	drm_kms_helper_poll_init(dev);
 	drm_kms_helper_poll_disable(dev);
diff --git a/include/drm/drm_mode_config.h b/include/drm/drm_mode_config.h
index 973119a9176b..47b005671e6a 100644
--- a/include/drm/drm_mode_config.h
+++ b/include/drm/drm_mode_config.h
@@ -918,6 +918,17 @@ struct drm_mode_config {
 	 */
 	bool async_page_flip;
 
+	/**
+	 * @atomic_async_page_flip_not_supported:
+	 *
+	 * If true, the driver does not support async page-flips with the
+	 * atomic uAPI. This is only used by old drivers which haven't yet
+	 * accomodated for &drm_crtc_state.async_flip in their atomic logic,
+	 * even if they have &drm_mode_config.async_page_flip set to true.
+	 * New drivers shall not set this flag.
+	 */
+	bool atomic_async_page_flip_not_supported;
+
 	/**
 	 * @fb_modifiers_not_supported:
 	 *
-- 
2.41.0

[PATCH v6 4/6] amd/display: indicate support for atomic async page-flips on DC

[André Almeida]

From: Simon Ser <contact@emersion.fr>

amdgpu_dm_commit_planes() already sets the flip_immediate flag for
async page-flips. This flag is used to set the UNP_FLIP_CONTROL
register. Thus, no additional change is required to handle async
page-flips with the atomic uAPI.

Signed-off-by: Simon Ser <contact@emersion.fr>
Reviewed-by: André Almeida <andrealmeid@igalia.com>
Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
Signed-off-by: André Almeida <andrealmeid@igalia.com>
---
v5: no changes
v4: no changes
---
 drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
index 4b433793f5a0..4d3d6009838c 100644
--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
+++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
@@ -3924,7 +3924,6 @@ static int amdgpu_dm_mode_config_init(struct amdgpu_device *adev)
 		adev_to_drm(adev)->mode_config.prefer_shadow = 1;
 	/* indicates support for immediate flip */
 	adev_to_drm(adev)->mode_config.async_page_flip = true;
-	adev_to_drm(adev)->mode_config.atomic_async_page_flip_not_supported = true;
 
 	state = kzalloc(sizeof(*state), GFP_KERNEL);
 	if (!state)
-- 
2.41.0

[PATCH v6 5/6] drm: Refuse to async flip with atomic prop changes

[André Almeida]

Given that prop changes may lead to modesetting, which would defeat the
fast path of the async flip, refuse any atomic prop change for async
flips in atomic API. The only exceptions are the framebuffer ID to flip
to and the mode ID, that could be referring to an identical mode.

Signed-off-by: André Almeida <andrealmeid@igalia.com>
---
v5: no changes
v4: new patch
---
 drivers/gpu/drm/drm_atomic_helper.c |  5 +++
 drivers/gpu/drm/drm_atomic_uapi.c   | 52 +++++++++++++++++++++++++++--
 drivers/gpu/drm/drm_crtc_internal.h |  2 +-
 drivers/gpu/drm/drm_mode_object.c   |  2 +-
 4 files changed, 56 insertions(+), 5 deletions(-)

diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
index 292e38eb6218..b34e3104afd1 100644
--- a/drivers/gpu/drm/drm_atomic_helper.c
+++ b/drivers/gpu/drm/drm_atomic_helper.c
@@ -629,6 +629,11 @@ drm_atomic_helper_check_modeset(struct drm_device *dev,
 		WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
 
 		if (!drm_mode_equal(&old_crtc_state->mode, &new_crtc_state->mode)) {
+			if (new_crtc_state->async_flip) {
+				drm_dbg_atomic(dev, "[CRTC:%d:%s] no mode changes allowed during async flip\n",
+					       crtc->base.id, crtc->name);
+				return -EINVAL;
+			}
 			drm_dbg_atomic(dev, "[CRTC:%d:%s] mode changed\n",
 				       crtc->base.id, crtc->name);
 			new_crtc_state->mode_changed = true;
diff --git a/drivers/gpu/drm/drm_atomic_uapi.c b/drivers/gpu/drm/drm_atomic_uapi.c
index a15121e75a0a..6c423a7e8c7b 100644
--- a/drivers/gpu/drm/drm_atomic_uapi.c
+++ b/drivers/gpu/drm/drm_atomic_uapi.c
@@ -1006,13 +1006,28 @@ int drm_atomic_connector_commit_dpms(struct drm_atomic_state *state,
 	return ret;
 }
 
+static int drm_atomic_check_prop_changes(int ret, uint64_t old_val, uint64_t prop_value,
+					 struct drm_property *prop)
+{
+	if (ret != 0 || old_val != prop_value) {
+		drm_dbg_atomic(prop->dev,
+			       "[PROP:%d:%s] No prop can be changed during async flip\n",
+			       prop->base.id, prop->name);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
 int drm_atomic_set_property(struct drm_atomic_state *state,
 			    struct drm_file *file_priv,
 			    struct drm_mode_object *obj,
 			    struct drm_property *prop,
-			    uint64_t prop_value)
+			    uint64_t prop_value,
+			    bool async_flip)
 {
 	struct drm_mode_object *ref;
+	uint64_t old_val;
 	int ret;
 
 	if (!drm_property_change_valid_get(prop, prop_value, &ref))
@@ -1029,6 +1044,13 @@ int drm_atomic_set_property(struct drm_atomic_state *state,
 			break;
 		}
 
+		if (async_flip) {
+			ret = drm_atomic_connector_get_property(connector, connector_state,
+								prop, &old_val);
+			ret = drm_atomic_check_prop_changes(ret, old_val, prop_value, prop);
+			break;
+		}
+
 		ret = drm_atomic_connector_set_property(connector,
 				connector_state, file_priv,
 				prop, prop_value);
@@ -1037,6 +1059,7 @@ int drm_atomic_set_property(struct drm_atomic_state *state,
 	case DRM_MODE_OBJECT_CRTC: {
 		struct drm_crtc *crtc = obj_to_crtc(obj);
 		struct drm_crtc_state *crtc_state;
+		struct drm_mode_config *config = &crtc->dev->mode_config;
 
 		crtc_state = drm_atomic_get_crtc_state(state, crtc);
 		if (IS_ERR(crtc_state)) {
@@ -1044,6 +1067,18 @@ int drm_atomic_set_property(struct drm_atomic_state *state,
 			break;
 		}
 
+		/*
+		 * We allow mode_id changes here for async flips, because we
+		 * check later on drm_atomic_helper_check_modeset() callers if
+		 * there are modeset changes or they are equal
+		 */
+		if (async_flip && prop != config->prop_mode_id) {
+			ret = drm_atomic_crtc_get_property(crtc, crtc_state,
+							   prop, &old_val);
+			ret = drm_atomic_check_prop_changes(ret, old_val, prop_value, prop);
+			break;
+		}
+
 		ret = drm_atomic_crtc_set_property(crtc,
 				crtc_state, prop, prop_value);
 		break;
@@ -1051,6 +1086,7 @@ int drm_atomic_set_property(struct drm_atomic_state *state,
 	case DRM_MODE_OBJECT_PLANE: {
 		struct drm_plane *plane = obj_to_plane(obj);
 		struct drm_plane_state *plane_state;
+		struct drm_mode_config *config = &plane->dev->mode_config;
 
 		plane_state = drm_atomic_get_plane_state(state, plane);
 		if (IS_ERR(plane_state)) {
@@ -1058,6 +1094,13 @@ int drm_atomic_set_property(struct drm_atomic_state *state,
 			break;
 		}
 
+		if (async_flip && prop != config->prop_fb_id) {
+			ret = drm_atomic_plane_get_property(plane, plane_state,
+							    prop, &old_val);
+			ret = drm_atomic_check_prop_changes(ret, old_val, prop_value, prop);
+			break;
+		}
+
 		ret = drm_atomic_plane_set_property(plane,
 				plane_state, file_priv,
 				prop, prop_value);
@@ -1349,6 +1392,7 @@ int drm_mode_atomic_ioctl(struct drm_device *dev,
 	struct drm_out_fence_state *fence_state;
 	int ret = 0;
 	unsigned int i, j, num_fences;
+	bool async_flip = false;
 
 	/* disallow for drivers not supporting atomic: */
 	if (!drm_core_check_feature(dev, DRIVER_ATOMIC))
@@ -1385,6 +1429,8 @@ int drm_mode_atomic_ioctl(struct drm_device *dev,
 				       "commit failed: DRM_MODE_PAGE_FLIP_ASYNC not supported with atomic\n");
 			return -EINVAL;
 		}
+
+		async_flip = true;
 	}
 
 	/* can't test and expect an event at the same time. */
@@ -1469,8 +1515,8 @@ int drm_mode_atomic_ioctl(struct drm_device *dev,
 				goto out;
 			}
 
-			ret = drm_atomic_set_property(state, file_priv,
-						      obj, prop, prop_value);
+			ret = drm_atomic_set_property(state, file_priv, obj,
+						      prop, prop_value, async_flip);
 			if (ret) {
 				drm_mode_object_put(obj);
 				goto out;
diff --git a/drivers/gpu/drm/drm_crtc_internal.h b/drivers/gpu/drm/drm_crtc_internal.h
index 501a10edd0e1..381130cebe81 100644
--- a/drivers/gpu/drm/drm_crtc_internal.h
+++ b/drivers/gpu/drm/drm_crtc_internal.h
@@ -251,7 +251,7 @@ int drm_atomic_set_property(struct drm_atomic_state *state,
 			    struct drm_file *file_priv,
 			    struct drm_mode_object *obj,
 			    struct drm_property *prop,
-			    uint64_t prop_value);
+			    uint64_t prop_value, bool async_flip);
 int drm_atomic_get_property(struct drm_mode_object *obj,
 			    struct drm_property *property, uint64_t *val);
 
diff --git a/drivers/gpu/drm/drm_mode_object.c b/drivers/gpu/drm/drm_mode_object.c
index ac0d2ce3f870..0e8355063eee 100644
--- a/drivers/gpu/drm/drm_mode_object.c
+++ b/drivers/gpu/drm/drm_mode_object.c
@@ -538,7 +538,7 @@ static int set_property_atomic(struct drm_mode_object *obj,
 						       obj_to_connector(obj),
 						       prop_value);
 	} else {
-		ret = drm_atomic_set_property(state, file_priv, obj, prop, prop_value);
+		ret = drm_atomic_set_property(state, file_priv, obj, prop, prop_value, false);
 		if (ret)
 			goto out;
 		ret = drm_atomic_commit(state);
-- 
2.41.0

Re: [PATCH v6 5/6] drm: Refuse to async flip with atomic prop changes

[Sebastian Wick]

On Tue, Aug 15, 2023 at 03:57:09PM -0300, André Almeida wrote:
> Given that prop changes may lead to modesetting, which would defeat the
> fast path of the async flip, refuse any atomic prop change for async
> flips in atomic API. The only exceptions are the framebuffer ID to flip
> to and the mode ID, that could be referring to an identical mode.

FYI, the solid fill series adds an enum drm_plane_pixel_source and and a
new solid fill pixel source. Changing the solid fill color would be
effectively the same as changing the FB_ID. On the other hand, changing
the FB_ID no longer necessarily results in an update when the pixel
source is set to solid fill.

> Signed-off-by: André Almeida <andrealmeid@igalia.com>
> ---
> v5: no changes
> v4: new patch
> ---
>  drivers/gpu/drm/drm_atomic_helper.c |  5 +++
>  drivers/gpu/drm/drm_atomic_uapi.c   | 52 +++++++++++++++++++++++++++--
>  drivers/gpu/drm/drm_crtc_internal.h |  2 +-
>  drivers/gpu/drm/drm_mode_object.c   |  2 +-
>  4 files changed, 56 insertions(+), 5 deletions(-)
> 
> diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
> index 292e38eb6218..b34e3104afd1 100644
> --- a/drivers/gpu/drm/drm_atomic_helper.c
> +++ b/drivers/gpu/drm/drm_atomic_helper.c
> @@ -629,6 +629,11 @@ drm_atomic_helper_check_modeset(struct drm_device *dev,
>  		WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
>  
>  		if (!drm_mode_equal(&old_crtc_state->mode, &new_crtc_state->mode)) {
> +			if (new_crtc_state->async_flip) {
> +				drm_dbg_atomic(dev, "[CRTC:%d:%s] no mode changes allowed during async flip\n",
> +					       crtc->base.id, crtc->name);
> +				return -EINVAL;
> +			}
>  			drm_dbg_atomic(dev, "[CRTC:%d:%s] mode changed\n",
>  				       crtc->base.id, crtc->name);
>  			new_crtc_state->mode_changed = true;
> diff --git a/drivers/gpu/drm/drm_atomic_uapi.c b/drivers/gpu/drm/drm_atomic_uapi.c
> index a15121e75a0a..6c423a7e8c7b 100644
> --- a/drivers/gpu/drm/drm_atomic_uapi.c
> +++ b/drivers/gpu/drm/drm_atomic_uapi.c
> @@ -1006,13 +1006,28 @@ int drm_atomic_connector_commit_dpms(struct drm_atomic_state *state,
>  	return ret;
>  }
>  
> +static int drm_atomic_check_prop_changes(int ret, uint64_t old_val, uint64_t prop_value,
> +					 struct drm_property *prop)
> +{
> +	if (ret != 0 || old_val != prop_value) {
> +		drm_dbg_atomic(prop->dev,
> +			       "[PROP:%d:%s] No prop can be changed during async flip\n",
> +			       prop->base.id, prop->name);
> +		return -EINVAL;
> +	}
> +
> +	return 0;
> +}
> +
>  int drm_atomic_set_property(struct drm_atomic_state *state,
>  			    struct drm_file *file_priv,
>  			    struct drm_mode_object *obj,
>  			    struct drm_property *prop,
> -			    uint64_t prop_value)
> +			    uint64_t prop_value,
> +			    bool async_flip)
>  {
>  	struct drm_mode_object *ref;
> +	uint64_t old_val;
>  	int ret;
>  
>  	if (!drm_property_change_valid_get(prop, prop_value, &ref))
> @@ -1029,6 +1044,13 @@ int drm_atomic_set_property(struct drm_atomic_state *state,
>  			break;
>  		}
>  
> +		if (async_flip) {
> +			ret = drm_atomic_connector_get_property(connector, connector_state,
> +								prop, &old_val);
> +			ret = drm_atomic_check_prop_changes(ret, old_val, prop_value, prop);
> +			break;
> +		}
> +
>  		ret = drm_atomic_connector_set_property(connector,
>  				connector_state, file_priv,
>  				prop, prop_value);
> @@ -1037,6 +1059,7 @@ int drm_atomic_set_property(struct drm_atomic_state *state,
>  	case DRM_MODE_OBJECT_CRTC: {
>  		struct drm_crtc *crtc = obj_to_crtc(obj);
>  		struct drm_crtc_state *crtc_state;
> +		struct drm_mode_config *config = &crtc->dev->mode_config;
>  
>  		crtc_state = drm_atomic_get_crtc_state(state, crtc);
>  		if (IS_ERR(crtc_state)) {
> @@ -1044,6 +1067,18 @@ int drm_atomic_set_property(struct drm_atomic_state *state,
>  			break;
>  		}
>  
> +		/*
> +		 * We allow mode_id changes here for async flips, because we
> +		 * check later on drm_atomic_helper_check_modeset() callers if
> +		 * there are modeset changes or they are equal
> +		 */
> +		if (async_flip && prop != config->prop_mode_id) {
> +			ret = drm_atomic_crtc_get_property(crtc, crtc_state,
> +							   prop, &old_val);
> +			ret = drm_atomic_check_prop_changes(ret, old_val, prop_value, prop);
> +			break;
> +		}
> +
>  		ret = drm_atomic_crtc_set_property(crtc,
>  				crtc_state, prop, prop_value);
>  		break;
> @@ -1051,6 +1086,7 @@ int drm_atomic_set_property(struct drm_atomic_state *state,
>  	case DRM_MODE_OBJECT_PLANE: {
>  		struct drm_plane *plane = obj_to_plane(obj);
>  		struct drm_plane_state *plane_state;
> +		struct drm_mode_config *config = &plane->dev->mode_config;
>  
>  		plane_state = drm_atomic_get_plane_state(state, plane);
>  		if (IS_ERR(plane_state)) {
> @@ -1058,6 +1094,13 @@ int drm_atomic_set_property(struct drm_atomic_state *state,
>  			break;
>  		}
>  
> +		if (async_flip && prop != config->prop_fb_id) {
> +			ret = drm_atomic_plane_get_property(plane, plane_state,
> +							    prop, &old_val);
> +			ret = drm_atomic_check_prop_changes(ret, old_val, prop_value, prop);
> +			break;
> +		}
> +
>  		ret = drm_atomic_plane_set_property(plane,
>  				plane_state, file_priv,
>  				prop, prop_value);
> @@ -1349,6 +1392,7 @@ int drm_mode_atomic_ioctl(struct drm_device *dev,
>  	struct drm_out_fence_state *fence_state;
>  	int ret = 0;
>  	unsigned int i, j, num_fences;
> +	bool async_flip = false;
>  
>  	/* disallow for drivers not supporting atomic: */
>  	if (!drm_core_check_feature(dev, DRIVER_ATOMIC))
> @@ -1385,6 +1429,8 @@ int drm_mode_atomic_ioctl(struct drm_device *dev,
>  				       "commit failed: DRM_MODE_PAGE_FLIP_ASYNC not supported with atomic\n");
>  			return -EINVAL;
>  		}
> +
> +		async_flip = true;
>  	}
>  
>  	/* can't test and expect an event at the same time. */
> @@ -1469,8 +1515,8 @@ int drm_mode_atomic_ioctl(struct drm_device *dev,
>  				goto out;
>  			}
>  
> -			ret = drm_atomic_set_property(state, file_priv,
> -						      obj, prop, prop_value);
> +			ret = drm_atomic_set_property(state, file_priv, obj,
> +						      prop, prop_value, async_flip);
>  			if (ret) {
>  				drm_mode_object_put(obj);
>  				goto out;
> diff --git a/drivers/gpu/drm/drm_crtc_internal.h b/drivers/gpu/drm/drm_crtc_internal.h
> index 501a10edd0e1..381130cebe81 100644
> --- a/drivers/gpu/drm/drm_crtc_internal.h
> +++ b/drivers/gpu/drm/drm_crtc_internal.h
> @@ -251,7 +251,7 @@ int drm_atomic_set_property(struct drm_atomic_state *state,
>  			    struct drm_file *file_priv,
>  			    struct drm_mode_object *obj,
>  			    struct drm_property *prop,
> -			    uint64_t prop_value);
> +			    uint64_t prop_value, bool async_flip);
>  int drm_atomic_get_property(struct drm_mode_object *obj,
>  			    struct drm_property *property, uint64_t *val);
>  
> diff --git a/drivers/gpu/drm/drm_mode_object.c b/drivers/gpu/drm/drm_mode_object.c
> index ac0d2ce3f870..0e8355063eee 100644
> --- a/drivers/gpu/drm/drm_mode_object.c
> +++ b/drivers/gpu/drm/drm_mode_object.c
> @@ -538,7 +538,7 @@ static int set_property_atomic(struct drm_mode_object *obj,
>  						       obj_to_connector(obj),
>  						       prop_value);
>  	} else {
> -		ret = drm_atomic_set_property(state, file_priv, obj, prop, prop_value);
> +		ret = drm_atomic_set_property(state, file_priv, obj, prop, prop_value, false);
>  		if (ret)
>  			goto out;
>  		ret = drm_atomic_commit(state);
> -- 
> 2.41.0
> 

Re: [PATCH v6 5/6] drm: Refuse to async flip with atomic prop changes

[Simon Ser]

On Tuesday, August 15th, 2023 at 20:57, André Almeida <andrealmeid@igalia.com> wrote:

> Given that prop changes may lead to modesetting, which would defeat the
> fast path of the async flip, refuse any atomic prop change for async
> flips in atomic API. The only exceptions are the framebuffer ID to flip
> to and the mode ID, that could be referring to an identical mode.
> 
> Signed-off-by: André Almeida <andrealmeid@igalia.com>
> ---
> v4: new patch
> ---
>  drivers/gpu/drm/drm_atomic_helper.c |  5 +++
>  drivers/gpu/drm/drm_atomic_uapi.c   | 52 +++++++++++++++++++++++++++--
>  drivers/gpu/drm/drm_crtc_internal.h |  2 +-
>  drivers/gpu/drm/drm_mode_object.c   |  2 +-
>  4 files changed, 56 insertions(+), 5 deletions(-)
> 
> diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c
> index 2c2c9caf0be5..1e2973f0e1f6 100644
> --- a/drivers/gpu/drm/drm_atomic_helper.c
> +++ b/drivers/gpu/drm/drm_atomic_helper.c
> @@ -629,6 +629,11 @@ drm_atomic_helper_check_modeset(struct drm_device *dev,
>  		WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
> 
>  		if (!drm_mode_equal(&old_crtc_state->mode, &new_crtc_state->mode)) {
> +			if (new_crtc_state->async_flip) {
> +				drm_dbg_atomic(dev, "[CRTC:%d:%s] no mode changes allowed during async flip\n",
> +					       crtc->base.id, crtc->name);
> +				return -EINVAL;
> +			}

Hmm, so, I've been going back and forth about this for a loooooong time. Each
time I convince myself that one of the options we have is a good solution, I
think of the drawbacks and change my mind. To sum up:

- Forbid non-FB_ID props from being included in the atomic commit: makes it
  painful for compositors, they need to have a special tearing codepath for no
  real reason and the tearing API doesn't work the same as the non-tearing API
  as Pekka said.
- Check any non-FB_ID props in the atomic commit, forbid changes here: we need
  to use get_property(), which is a bit weird back-and-forth between u64s used
  in the uAPI and actual underlying values stored in DRM structs. And the
  MODE_ID check is a bit split between the set_property() function and the
  check_modeset() one. Ideally we'd have a something_changed bool like we have
  for modesets (mode_changed) but that would be a massive pain to plumb through
  all of the props. Also get_property() is lightweight, it just casts whatever
  struct field is being used to u64 and that's it.

All in all, I think I'd settle on the approach in this patch, but I'd prefer to
leave the MODE_ID stuff out. It would result in a less convoluted check, and I
can't think of any current compositor which re-creates the mode blob each
page-flip. That's not 100% consistent with the sync page-flip API, but I'm
worried about accumulating more special cases like this in the future.

Does that make sense?

>  			drm_dbg_atomic(dev, "[CRTC:%d:%s] mode changed\n",
>  				       crtc->base.id, crtc->name);
>  			new_crtc_state->mode_changed = true;
> diff --git a/drivers/gpu/drm/drm_atomic_uapi.c b/drivers/gpu/drm/drm_atomic_uapi.c
> index dfd4cf7169df..536c21f53b5f 100644
> --- a/drivers/gpu/drm/drm_atomic_uapi.c
> +++ b/drivers/gpu/drm/drm_atomic_uapi.c
> @@ -972,13 +972,28 @@ int drm_atomic_connector_commit_dpms(struct drm_atomic_state *state,
>  	return ret;
>  }
> 
> +static int drm_atomic_check_prop_changes(int ret, uint64_t old_val, uint64_t prop_value,
> +					 struct drm_property *prop)
> +{
> +	if (ret != 0 || old_val != prop_value) {
> +		drm_dbg_atomic(prop->dev,
> +			       "[PROP:%d:%s] No prop can be changed during async flip\n",
> +			       prop->base.id, prop->name);
> +		return -EINVAL;
> +	}
> +
> +	return 0;
> +}
> +
>  int drm_atomic_set_property(struct drm_atomic_state *state,
>  			    struct drm_file *file_priv,
>  			    struct drm_mode_object *obj,
>  			    struct drm_property *prop,
> -			    uint64_t prop_value)
> +			    uint64_t prop_value,
> +			    bool async_flip)
>  {
>  	struct drm_mode_object *ref;
> +	uint64_t old_val;
>  	int ret;
> 
>  	if (!drm_property_change_valid_get(prop, prop_value, &ref))
> @@ -995,6 +1010,13 @@ int drm_atomic_set_property(struct drm_atomic_state *state,
>  			break;
>  		}
> 
> +		if (async_flip) {
> +			ret = drm_atomic_connector_get_property(connector, connector_state,
> +								prop, &old_val);
> +			ret = drm_atomic_check_prop_changes(ret, old_val, prop_value, prop);

Note to self: I was worried here to pass the "next" state to get_property(),
but it's before the set_property() call on that state, so should be fine.

> +			break;
> +		}
> +
>  		ret = drm_atomic_connector_set_property(connector,
>  				connector_state, file_priv,
>  				prop, prop_value);
> @@ -1003,6 +1025,7 @@ int drm_atomic_set_property(struct drm_atomic_state *state,
>  	case DRM_MODE_OBJECT_CRTC: {
>  		struct drm_crtc *crtc = obj_to_crtc(obj);
>  		struct drm_crtc_state *crtc_state;
> +		struct drm_mode_config *config = &crtc->dev->mode_config;
> 
>  		crtc_state = drm_atomic_get_crtc_state(state, crtc);
>  		if (IS_ERR(crtc_state)) {
> @@ -1010,6 +1033,18 @@ int drm_atomic_set_property(struct drm_atomic_state *state,
>  			break;
>  		}
> 
> +		/*
> +		 * We allow mode_id changes here for async flips, because we
> +		 * check later on drm_atomic_helper_check_modeset() callers if
> +		 * there are modeset changes or they are equal
> +		 */
> +		if (async_flip && prop != config->prop_mode_id) {
> +			ret = drm_atomic_crtc_get_property(crtc, crtc_state,
> +							   prop, &old_val);
> +			ret = drm_atomic_check_prop_changes(ret, old_val, prop_value, prop);
> +			break;
> +		}
> +
>  		ret = drm_atomic_crtc_set_property(crtc,
>  				crtc_state, prop, prop_value);
>  		break;
> @@ -1017,6 +1052,7 @@ int drm_atomic_set_property(struct drm_atomic_state *state,
>  	case DRM_MODE_OBJECT_PLANE: {
>  		struct drm_plane *plane = obj_to_plane(obj);
>  		struct drm_plane_state *plane_state;
> +		struct drm_mode_config *config = &plane->dev->mode_config;
> 
>  		plane_state = drm_atomic_get_plane_state(state, plane);
>  		if (IS_ERR(plane_state)) {
> @@ -1024,6 +1060,13 @@ int drm_atomic_set_property(struct drm_atomic_state *state,
>  			break;
>  		}
> 
> +		if (async_flip && prop != config->prop_fb_id) {
> +			ret = drm_atomic_plane_get_property(plane, plane_state,
> +							    prop, &old_val);
> +			ret = drm_atomic_check_prop_changes(ret, old_val, prop_value, prop);
> +			break;
> +		}
> +
>  		ret = drm_atomic_plane_set_property(plane,
>  				plane_state, file_priv,
>  				prop, prop_value);
> @@ -1312,6 +1355,7 @@ int drm_mode_atomic_ioctl(struct drm_device *dev,
>  	struct drm_out_fence_state *fence_state;
>  	int ret = 0;
>  	unsigned int i, j, num_fences;
> +	bool async_flip = false;
> 
>  	/* disallow for drivers not supporting atomic: */
>  	if (!drm_core_check_feature(dev, DRIVER_ATOMIC))
> @@ -1348,6 +1392,8 @@ int drm_mode_atomic_ioctl(struct drm_device *dev,
>  				       "commit failed: DRM_MODE_PAGE_FLIP_ASYNC not supported with atomic\n");
>  			return -EINVAL;
>  		}
> +
> +		async_flip = true;
>  	}
> 
>  	/* can't test and expect an event at the same time. */
> @@ -1427,8 +1473,8 @@ int drm_mode_atomic_ioctl(struct drm_device *dev,
>  				goto out;
>  			}
> 
> -			ret = drm_atomic_set_property(state, file_priv,
> -						      obj, prop, prop_value);
> +			ret = drm_atomic_set_property(state, file_priv, obj,
> +						      prop, prop_value, async_flip);
>  			if (ret) {
>  				drm_mode_object_put(obj);
>  				goto out;
> diff --git a/drivers/gpu/drm/drm_crtc_internal.h b/drivers/gpu/drm/drm_crtc_internal.h
> index 501a10edd0e1..381130cebe81 100644
> --- a/drivers/gpu/drm/drm_crtc_internal.h
> +++ b/drivers/gpu/drm/drm_crtc_internal.h
> @@ -251,7 +251,7 @@ int drm_atomic_set_property(struct drm_atomic_state *state,
>  			    struct drm_file *file_priv,
>  			    struct drm_mode_object *obj,
>  			    struct drm_property *prop,
> -			    uint64_t prop_value);
> +			    uint64_t prop_value, bool async_flip);
>  int drm_atomic_get_property(struct drm_mode_object *obj,
>  			    struct drm_property *property, uint64_t *val);
> 
> diff --git a/drivers/gpu/drm/drm_mode_object.c b/drivers/gpu/drm/drm_mode_object.c
> index ba1608effc0f..64f519254895 100644
> --- a/drivers/gpu/drm/drm_mode_object.c
> +++ b/drivers/gpu/drm/drm_mode_object.c
> @@ -536,7 +536,7 @@ static int set_property_atomic(struct drm_mode_object *obj,
>  						       obj_to_connector(obj),
>  						       prop_value);
>  	} else {
> -		ret = drm_atomic_set_property(state, file_priv, obj, prop, prop_value);
> +		ret = drm_atomic_set_property(state, file_priv, obj, prop, prop_value, false);
>  		if (ret)
>  			goto out;
>  		ret = drm_atomic_commit(state);
> --
> 2.41.0

[PATCH v6 6/6] drm/doc: Define KMS atomic state set

[André Almeida]

From: Pekka Paalanen <pekka.paalanen@collabora.com>

Specify how the atomic state is maintained between userspace and
kernel, plus the special case for async flips.

Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
Signed-off-by: André Almeida <andrealmeid@igalia.com>
---
v5: Add note that not every redundant attribute will result in no-op
v4: total rework by Pekka
---
 Documentation/gpu/drm-uapi.rst | 44 ++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/Documentation/gpu/drm-uapi.rst b/Documentation/gpu/drm-uapi.rst
index 65fb3036a580..b91ccaddeeb9 100644
--- a/Documentation/gpu/drm-uapi.rst
+++ b/Documentation/gpu/drm-uapi.rst
@@ -486,3 +486,47 @@ and the CRTC index is its position in this array.
 
 .. kernel-doc:: include/uapi/drm/drm_mode.h
    :internal:
+
+KMS atomic state
+================
+
+An atomic commit can change multiple KMS properties in an atomic fashion,
+without ever applying intermediate or partial state changes.  Either the whole
+commit succeeds or fails, and it will never be applied partially. This is the
+fundamental improvement of the atomic API over the older non-atomic API which is
+referred to as the "legacy API".  Applying intermediate state could unexpectedly
+fail, cause visible glitches, or delay reaching the final state.
+
+An atomic commit can be flagged with DRM_MODE_ATOMIC_TEST_ONLY, which means the
+complete state change is validated but not applied.  Userspace should use this
+flag to validate any state change before asking to apply it. If validation fails
+for any reason, userspace should attempt to fall back to another, perhaps
+simpler, final state.  This allows userspace to probe for various configurations
+without causing visible glitches on screen and without the need to undo a
+probing change.
+
+The changes recorded in an atomic commit apply on top the current KMS state in
+the kernel. Hence, the complete new KMS state is the complete old KMS state with
+the committed property settings done on top. The kernel will try to avoid
+no-operation changes, so it is safe for userspace to send redundant property
+settings.  However, not every situation allows for no-op changes, due to the
+need to acquire locks for some attributes. Userspace needs to be aware that some
+redundant information might result in oversynchronization issues.  No-operation
+changes do not count towards actually needed changes, e.g.  setting MODE_ID to a
+different blob with identical contents as the current KMS state shall not be a
+modeset on its own.
+
+A "modeset" is a change in KMS state that might enable, disable, or temporarily
+disrupt the emitted video signal, possibly causing visible glitches on screen. A
+modeset may also take considerably more time to complete than other kinds of
+changes, and the video sink might also need time to adapt to the new signal
+properties. Therefore a modeset must be explicitly allowed with the flag
+DRM_MODE_ATOMIC_ALLOW_MODESET.  This in combination with
+DRM_MODE_ATOMIC_TEST_ONLY allows userspace to determine if a state change is
+likely to cause visible disruption on screen and avoid such changes when end
+users do not expect them.
+
+An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
+effectively change only the FB_ID property on any planes. No-operation changes
+are ignored as always. Changing any other property will cause the commit to be
+rejected.
-- 
2.41.0

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[Michel Dänzer]

On 8/15/23 20:57, André Almeida wrote:
> From: Pekka Paalanen <pekka.paalanen@collabora.com>
> 
> Specify how the atomic state is maintained between userspace and
> kernel, plus the special case for async flips.
> 
> Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
> Signed-off-by: André Almeida <andrealmeid@igalia.com>

[...]

> +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
> +effectively change only the FB_ID property on any planes. No-operation changes
> +are ignored as always. [...]

During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.


-- 
Earthling Michel Dänzer            |                  https://redhat.com
Libre software enthusiast          |         Mesa and Xwayland developer

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[Michel Dänzer]

On 8/17/23 12:37, Michel Dänzer wrote:
> On 8/15/23 20:57, André Almeida wrote:
>> From: Pekka Paalanen <pekka.paalanen@collabora.com>
>>
>> Specify how the atomic state is maintained between userspace and
>> kernel, plus the special case for async flips.
>>
>> Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
>> Signed-off-by: André Almeida <andrealmeid@igalia.com>
> 
> [...]
> 
>> +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
>> +effectively change only the FB_ID property on any planes. No-operation changes
>> +are ignored as always. [...]
> 
> During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.

That said, it doesn't make too much sense to use DRM_MODE_PAGE_FLIP_ASYNC for this, since it won't have any effect outside of vertical blank anyway.


-- 
Earthling Michel Dänzer            |                  https://redhat.com
Libre software enthusiast          |         Mesa and Xwayland developer

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[André Almeida]

Hi Michel,

Em 17/08/2023 07:37, Michel Dänzer escreveu:
> On 8/15/23 20:57, André Almeida wrote:
>> From: Pekka Paalanen <pekka.paalanen@collabora.com>
>>
>> Specify how the atomic state is maintained between userspace and
>> kernel, plus the special case for async flips.
>>
>> Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
>> Signed-off-by: André Almeida <andrealmeid@igalia.com>
> 
> [...]
> 
>> +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
>> +effectively change only the FB_ID property on any planes. No-operation changes
>> +are ignored as always. [...]
> 
> During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.
> 

I believe the documentation already addresses that sending redundant 
information may not lead to the desired behavior during an async flip. 
Do you think adding a note about using the same FB_ID would be helpful?

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[Michel Dänzer]

On 8/21/23 22:02, André Almeida wrote:
> Em 17/08/2023 07:37, Michel Dänzer escreveu:
>> On 8/15/23 20:57, André Almeida wrote:
>>> From: Pekka Paalanen <pekka.paalanen@collabora.com>
>>>
>>> Specify how the atomic state is maintained between userspace and
>>> kernel, plus the special case for async flips.
>>>
>>> Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
>>> Signed-off-by: André Almeida <andrealmeid@igalia.com>
>>
>> [...]
>>
>>> +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
>>> +effectively change only the FB_ID property on any planes. No-operation changes
>>> +are ignored as always. [...]
>>
>> During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.
>>
> 
> I believe the documentation already addresses that sending redundant information may not lead to the desired behavior during an async flip. Do you think adding a note about using the same FB_ID would be helpful?

Maybe not.


-- 
Earthling Michel Dänzer            |                  https://redhat.com
Libre software enthusiast          |         Mesa and Xwayland developer

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[André Almeida]

Hi Michel,

On 8/17/23 12:37, Michel Dänzer wrote:
> On 8/15/23 20:57, André Almeida wrote:
>> From: Pekka Paalanen <pekka.paalanen@collabora.com>
>>
>> Specify how the atomic state is maintained between userspace and
>> kernel, plus the special case for async flips.
>>
>> Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
>> Signed-off-by: André Almeida <andrealmeid@igalia.com>
> [...]
>
>> +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
>> +effectively change only the FB_ID property on any planes. No-operation changes
>> +are ignored as always. [...]
> During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.
>
Xaver tested this hypothesis in a flipping the same fb in a VRR monitor 
and it worked as expected, so this shouldn't be a concern.

Thanks,
     André

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[Pekka Paalanen]

[-- Attachment #1: Type: text/plain, Size: 1446 bytes --]

On Mon, 16 Oct 2023 12:52:32 +0200
André Almeida <andrealmeid@igalia.com> wrote:

> Hi Michel,
> 
> On 8/17/23 12:37, Michel Dänzer wrote:
> > On 8/15/23 20:57, André Almeida wrote:  
> >> From: Pekka Paalanen <pekka.paalanen@collabora.com>
> >>
> >> Specify how the atomic state is maintained between userspace and
> >> kernel, plus the special case for async flips.
> >>
> >> Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
> >> Signed-off-by: André Almeida <andrealmeid@igalia.com>  
> > [...]
> >  
> >> +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
> >> +effectively change only the FB_ID property on any planes. No-operation changes
> >> +are ignored as always. [...]  
> > During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.
> >  
> Xaver tested this hypothesis in a flipping the same fb in a VRR monitor 
> and it worked as expected, so this shouldn't be a concern.

Right, so it must have some effect. It cannot be simply ignored like in
the proposed doc wording. Do we special-case re-setting the same FB_ID
as "not a no-op" or "not ignored" or some other way?


Thanks,
pq

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[André Almeida]

Hi Pekka,

On 10/16/23 14:18, Pekka Paalanen wrote:
> On Mon, 16 Oct 2023 12:52:32 +0200
> André Almeida <andrealmeid@igalia.com> wrote:
>
>> Hi Michel,
>>
>> On 8/17/23 12:37, Michel Dänzer wrote:
>>> On 8/15/23 20:57, André Almeida wrote:
>>>> From: Pekka Paalanen <pekka.paalanen@collabora.com>
>>>>
>>>> Specify how the atomic state is maintained between userspace and
>>>> kernel, plus the special case for async flips.
>>>>
>>>> Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
>>>> Signed-off-by: André Almeida <andrealmeid@igalia.com>
>>> [...]
>>>   
>>>> +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
>>>> +effectively change only the FB_ID property on any planes. No-operation changes
>>>> +are ignored as always. [...]
>>> During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.
>>>   
>> Xaver tested this hypothesis in a flipping the same fb in a VRR monitor
>> and it worked as expected, so this shouldn't be a concern.
> Right, so it must have some effect. It cannot be simply ignored like in
> the proposed doc wording. Do we special-case re-setting the same FB_ID
> as "not a no-op" or "not ignored" or some other way?
There's an effect in the refresh rate, the image won't change but it 
will report that a flip had happened asynchronously so the reported 
framerate will be increased. Maybe an additional wording could be like:

Flipping to the same FB_ID will result in a immediate flip as if it was 
changing to a different one, with no effect on the image but effecting 
the reported frame rate.


>
> Thanks,
> pq

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[Pekka Paalanen]

[-- Attachment #1: Type: text/plain, Size: 3432 bytes --]

On Mon, 16 Oct 2023 15:42:16 +0200
André Almeida <andrealmeid@igalia.com> wrote:

> Hi Pekka,
> 
> On 10/16/23 14:18, Pekka Paalanen wrote:
> > On Mon, 16 Oct 2023 12:52:32 +0200
> > André Almeida <andrealmeid@igalia.com> wrote:
> >  
> >> Hi Michel,
> >>
> >> On 8/17/23 12:37, Michel Dänzer wrote:  
> >>> On 8/15/23 20:57, André Almeida wrote:  
> >>>> From: Pekka Paalanen <pekka.paalanen@collabora.com>
> >>>>
> >>>> Specify how the atomic state is maintained between userspace and
> >>>> kernel, plus the special case for async flips.
> >>>>
> >>>> Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
> >>>> Signed-off-by: André Almeida <andrealmeid@igalia.com>  
> >>> [...]
> >>>     
> >>>> +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
> >>>> +effectively change only the FB_ID property on any planes. No-operation changes
> >>>> +are ignored as always. [...]  
> >>> During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.
> >>>     
> >> Xaver tested this hypothesis in a flipping the same fb in a VRR monitor
> >> and it worked as expected, so this shouldn't be a concern.  
> > Right, so it must have some effect. It cannot be simply ignored like in
> > the proposed doc wording. Do we special-case re-setting the same FB_ID
> > as "not a no-op" or "not ignored" or some other way?  
> There's an effect in the refresh rate, the image won't change but it 
> will report that a flip had happened asynchronously so the reported 
> framerate will be increased. Maybe an additional wording could be like:
> 
> Flipping to the same FB_ID will result in a immediate flip as if it was 
> changing to a different one, with no effect on the image but effecting 
> the reported frame rate.

Re-setting FB_ID to its current value is a special case regardless of
PAGE_FLIP_ASYNC, is it not?

So it should be called out somewhere that applies regardless of
PAGE_FLIP_ASYNC. Maybe to the end of the earlier paragraph:

> +The changes recorded in an atomic commit apply on top the current KMS state in
> +the kernel. Hence, the complete new KMS state is the complete old KMS state with
> +the committed property settings done on top. The kernel will try to avoid
> +no-operation changes, so it is safe for userspace to send redundant property
> +settings.  However, not every situation allows for no-op changes, due to the
> +need to acquire locks for some attributes. Userspace needs to be aware that some
> +redundant information might result in oversynchronization issues.  No-operation
> +changes do not count towards actually needed changes, e.g.  setting MODE_ID to a
> +different blob with identical contents as the current KMS state shall not be a
> +modeset on its own.

+As a special exception for VRR needs, explicitly setting FB_ID to its
+current value is not a no-op.

Would that work?

I'd like to try to avoid being more specific about what it does
exactly, because that's not the topic here. Such things can be
documented with the property itself. This is a summary of what is or is
not a no-op or a modeset.


Thanks,
pq

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[André Almeida]

On 10/16/23 16:52, Pekka Paalanen wrote:
> On Mon, 16 Oct 2023 15:42:16 +0200
> André Almeida <andrealmeid@igalia.com> wrote:
>
>> Hi Pekka,
>>
>> On 10/16/23 14:18, Pekka Paalanen wrote:
>>> On Mon, 16 Oct 2023 12:52:32 +0200
>>> André Almeida <andrealmeid@igalia.com> wrote:
>>>   
>>>> Hi Michel,
>>>>
>>>> On 8/17/23 12:37, Michel Dänzer wrote:
>>>>> On 8/15/23 20:57, André Almeida wrote:
>>>>>> From: Pekka Paalanen <pekka.paalanen@collabora.com>
>>>>>>
>>>>>> Specify how the atomic state is maintained between userspace and
>>>>>> kernel, plus the special case for async flips.
>>>>>>
>>>>>> Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
>>>>>> Signed-off-by: André Almeida <andrealmeid@igalia.com>
>>>>> [...]
>>>>>      
>>>>>> +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
>>>>>> +effectively change only the FB_ID property on any planes. No-operation changes
>>>>>> +are ignored as always. [...]
>>>>> During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.
>>>>>      
>>>> Xaver tested this hypothesis in a flipping the same fb in a VRR monitor
>>>> and it worked as expected, so this shouldn't be a concern.
>>> Right, so it must have some effect. It cannot be simply ignored like in
>>> the proposed doc wording. Do we special-case re-setting the same FB_ID
>>> as "not a no-op" or "not ignored" or some other way?
>> There's an effect in the refresh rate, the image won't change but it
>> will report that a flip had happened asynchronously so the reported
>> framerate will be increased. Maybe an additional wording could be like:
>>
>> Flipping to the same FB_ID will result in a immediate flip as if it was
>> changing to a different one, with no effect on the image but effecting
>> the reported frame rate.
> Re-setting FB_ID to its current value is a special case regardless of
> PAGE_FLIP_ASYNC, is it not?
>
> So it should be called out somewhere that applies regardless of
> PAGE_FLIP_ASYNC. Maybe to the end of the earlier paragraph:
>
>> +The changes recorded in an atomic commit apply on top the current KMS state in
>> +the kernel. Hence, the complete new KMS state is the complete old KMS state with
>> +the committed property settings done on top. The kernel will try to avoid
>> +no-operation changes, so it is safe for userspace to send redundant property
>> +settings.  However, not every situation allows for no-op changes, due to the
>> +need to acquire locks for some attributes. Userspace needs to be aware that some
>> +redundant information might result in oversynchronization issues.  No-operation
>> +changes do not count towards actually needed changes, e.g.  setting MODE_ID to a
>> +different blob with identical contents as the current KMS state shall not be a
>> +modeset on its own.
> +As a special exception for VRR needs, explicitly setting FB_ID to its
> +current value is not a no-op.
>
> Would that work?

I liked this suggestion, thanks! I'll wrap up a v7

> I'd like to try to avoid being more specific about what it does
> exactly, because that's not the topic here. Such things can be
> documented with the property itself. This is a summary of what is or is
> not a no-op or a modeset.
>
>
> Thanks,
> pq

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[Ville Syrjälä]

On Mon, Oct 16, 2023 at 05:52:22PM +0300, Pekka Paalanen wrote:
> On Mon, 16 Oct 2023 15:42:16 +0200
> André Almeida <andrealmeid@igalia.com> wrote:
> 
> > Hi Pekka,
> > 
> > On 10/16/23 14:18, Pekka Paalanen wrote:
> > > On Mon, 16 Oct 2023 12:52:32 +0200
> > > André Almeida <andrealmeid@igalia.com> wrote:
> > >  
> > >> Hi Michel,
> > >>
> > >> On 8/17/23 12:37, Michel Dänzer wrote:  
> > >>> On 8/15/23 20:57, André Almeida wrote:  
> > >>>> From: Pekka Paalanen <pekka.paalanen@collabora.com>
> > >>>>
> > >>>> Specify how the atomic state is maintained between userspace and
> > >>>> kernel, plus the special case for async flips.
> > >>>>
> > >>>> Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
> > >>>> Signed-off-by: André Almeida <andrealmeid@igalia.com>  
> > >>> [...]
> > >>>     
> > >>>> +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
> > >>>> +effectively change only the FB_ID property on any planes. No-operation changes
> > >>>> +are ignored as always. [...]  
> > >>> During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.
> > >>>     
> > >> Xaver tested this hypothesis in a flipping the same fb in a VRR monitor
> > >> and it worked as expected, so this shouldn't be a concern.  
> > > Right, so it must have some effect. It cannot be simply ignored like in
> > > the proposed doc wording. Do we special-case re-setting the same FB_ID
> > > as "not a no-op" or "not ignored" or some other way?  
> > There's an effect in the refresh rate, the image won't change but it 
> > will report that a flip had happened asynchronously so the reported 
> > framerate will be increased. Maybe an additional wording could be like:
> > 
> > Flipping to the same FB_ID will result in a immediate flip as if it was 
> > changing to a different one, with no effect on the image but effecting 
> > the reported frame rate.
> 
> Re-setting FB_ID to its current value is a special case regardless of
> PAGE_FLIP_ASYNC, is it not?

No. The rule has so far been that all side effects are observed
even if you flip to the same fb. And that is one of my annoyances
with this proposal. The rules will now be different for async flips
vs. everything else.

The other issues (mainly relating to hardware where not all planes
support async flips) I've already highlighted in some earlier mail.

-- 
Ville Syrjälä
Intel

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[Simon Ser]

On Monday, October 16th, 2023 at 17:10, Ville Syrjälä <ville.syrjala@linux.intel.com> wrote:

> On Mon, Oct 16, 2023 at 05:52:22PM +0300, Pekka Paalanen wrote:
> 
> > On Mon, 16 Oct 2023 15:42:16 +0200
> > André Almeida andrealmeid@igalia.com wrote:
> > 
> > > Hi Pekka,
> > > 
> > > On 10/16/23 14:18, Pekka Paalanen wrote:
> > > 
> > > > On Mon, 16 Oct 2023 12:52:32 +0200
> > > > André Almeida andrealmeid@igalia.com wrote:
> > > > 
> > > > > Hi Michel,
> > > > > 
> > > > > On 8/17/23 12:37, Michel Dänzer wrote:
> > > > > 
> > > > > > On 8/15/23 20:57, André Almeida wrote:
> > > > > > 
> > > > > > > From: Pekka Paalanen pekka.paalanen@collabora.com
> > > > > > > 
> > > > > > > Specify how the atomic state is maintained between userspace and
> > > > > > > kernel, plus the special case for async flips.
> > > > > > > 
> > > > > > > Signed-off-by: Pekka Paalanen pekka.paalanen@collabora.com
> > > > > > > Signed-off-by: André Almeida andrealmeid@igalia.com
> > > > > > > [...]
> > > > > > 
> > > > > > > +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
> > > > > > > +effectively change only the FB_ID property on any planes. No-operation changes
> > > > > > > +are ignored as always. [...]
> > > > > > > During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.
> > > > > 
> > > > > Xaver tested this hypothesis in a flipping the same fb in a VRR monitor
> > > > > and it worked as expected, so this shouldn't be a concern.
> > > > > Right, so it must have some effect. It cannot be simply ignored like in
> > > > > the proposed doc wording. Do we special-case re-setting the same FB_ID
> > > > > as "not a no-op" or "not ignored" or some other way?
> > > > > There's an effect in the refresh rate, the image won't change but it
> > > > > will report that a flip had happened asynchronously so the reported
> > > > > framerate will be increased. Maybe an additional wording could be like:
> > > 
> > > Flipping to the same FB_ID will result in a immediate flip as if it was
> > > changing to a different one, with no effect on the image but effecting
> > > the reported frame rate.
> > 
> > Re-setting FB_ID to its current value is a special case regardless of
> > PAGE_FLIP_ASYNC, is it not?
> 
> No. The rule has so far been that all side effects are observed
> even if you flip to the same fb. And that is one of my annoyances
> with this proposal. The rules will now be different for async flips
> vs. everything else.

Well with the patches the async page-flip case is exactly the same as
the non-async page-flip case. In both cases, if a FB_ID is included in
an atomic commit then the side effects are triggered even if the property
value didn't change. The rules are the same for everything.

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[Ville Syrjälä]

On Mon, Oct 16, 2023 at 10:00:51PM +0000, Simon Ser wrote:
> On Monday, October 16th, 2023 at 17:10, Ville Syrjälä <ville.syrjala@linux.intel.com> wrote:
> 
> > On Mon, Oct 16, 2023 at 05:52:22PM +0300, Pekka Paalanen wrote:
> > 
> > > On Mon, 16 Oct 2023 15:42:16 +0200
> > > André Almeida andrealmeid@igalia.com wrote:
> > > 
> > > > Hi Pekka,
> > > > 
> > > > On 10/16/23 14:18, Pekka Paalanen wrote:
> > > > 
> > > > > On Mon, 16 Oct 2023 12:52:32 +0200
> > > > > André Almeida andrealmeid@igalia.com wrote:
> > > > > 
> > > > > > Hi Michel,
> > > > > > 
> > > > > > On 8/17/23 12:37, Michel Dänzer wrote:
> > > > > > 
> > > > > > > On 8/15/23 20:57, André Almeida wrote:
> > > > > > > 
> > > > > > > > From: Pekka Paalanen pekka.paalanen@collabora.com
> > > > > > > > 
> > > > > > > > Specify how the atomic state is maintained between userspace and
> > > > > > > > kernel, plus the special case for async flips.
> > > > > > > > 
> > > > > > > > Signed-off-by: Pekka Paalanen pekka.paalanen@collabora.com
> > > > > > > > Signed-off-by: André Almeida andrealmeid@igalia.com
> > > > > > > > [...]
> > > > > > > 
> > > > > > > > +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
> > > > > > > > +effectively change only the FB_ID property on any planes. No-operation changes
> > > > > > > > +are ignored as always. [...]
> > > > > > > > During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.
> > > > > > 
> > > > > > Xaver tested this hypothesis in a flipping the same fb in a VRR monitor
> > > > > > and it worked as expected, so this shouldn't be a concern.
> > > > > > Right, so it must have some effect. It cannot be simply ignored like in
> > > > > > the proposed doc wording. Do we special-case re-setting the same FB_ID
> > > > > > as "not a no-op" or "not ignored" or some other way?
> > > > > > There's an effect in the refresh rate, the image won't change but it
> > > > > > will report that a flip had happened asynchronously so the reported
> > > > > > framerate will be increased. Maybe an additional wording could be like:
> > > > 
> > > > Flipping to the same FB_ID will result in a immediate flip as if it was
> > > > changing to a different one, with no effect on the image but effecting
> > > > the reported frame rate.
> > > 
> > > Re-setting FB_ID to its current value is a special case regardless of
> > > PAGE_FLIP_ASYNC, is it not?
> > 
> > No. The rule has so far been that all side effects are observed
> > even if you flip to the same fb. And that is one of my annoyances
> > with this proposal. The rules will now be different for async flips
> > vs. everything else.
> 
> Well with the patches the async page-flip case is exactly the same as
> the non-async page-flip case. In both cases, if a FB_ID is included in
> an atomic commit then the side effects are triggered even if the property
> value didn't change. The rules are the same for everything.

I see it only checking if FB_ID changes or not. If it doesn't
change then the implication is that the side effects will in
fact be skipped as not all planes may even support async flips.

-- 
Ville Syrjälä
Intel

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[Simon Ser]

On Tuesday, October 17th, 2023 at 14:10, Ville Syrjälä <ville.syrjala@linux.intel.com> wrote:

> On Mon, Oct 16, 2023 at 10:00:51PM +0000, Simon Ser wrote:
> 
> > On Monday, October 16th, 2023 at 17:10, Ville Syrjälä ville.syrjala@linux.intel.com wrote:
> > 
> > > On Mon, Oct 16, 2023 at 05:52:22PM +0300, Pekka Paalanen wrote:
> > > 
> > > > On Mon, 16 Oct 2023 15:42:16 +0200
> > > > André Almeida andrealmeid@igalia.com wrote:
> > > > 
> > > > > Hi Pekka,
> > > > > 
> > > > > On 10/16/23 14:18, Pekka Paalanen wrote:
> > > > > 
> > > > > > On Mon, 16 Oct 2023 12:52:32 +0200
> > > > > > André Almeida andrealmeid@igalia.com wrote:
> > > > > > 
> > > > > > > Hi Michel,
> > > > > > > 
> > > > > > > On 8/17/23 12:37, Michel Dänzer wrote:
> > > > > > > 
> > > > > > > > On 8/15/23 20:57, André Almeida wrote:
> > > > > > > > 
> > > > > > > > > From: Pekka Paalanen pekka.paalanen@collabora.com
> > > > > > > > > 
> > > > > > > > > Specify how the atomic state is maintained between userspace and
> > > > > > > > > kernel, plus the special case for async flips.
> > > > > > > > > 
> > > > > > > > > Signed-off-by: Pekka Paalanen pekka.paalanen@collabora.com
> > > > > > > > > Signed-off-by: André Almeida andrealmeid@igalia.com
> > > > > > > > > [...]
> > > > > > > > 
> > > > > > > > > +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
> > > > > > > > > +effectively change only the FB_ID property on any planes. No-operation changes
> > > > > > > > > +are ignored as always. [...]
> > > > > > > > > During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.
> > > > > > > 
> > > > > > > Xaver tested this hypothesis in a flipping the same fb in a VRR monitor
> > > > > > > and it worked as expected, so this shouldn't be a concern.
> > > > > > > Right, so it must have some effect. It cannot be simply ignored like in
> > > > > > > the proposed doc wording. Do we special-case re-setting the same FB_ID
> > > > > > > as "not a no-op" or "not ignored" or some other way?
> > > > > > > There's an effect in the refresh rate, the image won't change but it
> > > > > > > will report that a flip had happened asynchronously so the reported
> > > > > > > framerate will be increased. Maybe an additional wording could be like:
> > > > > 
> > > > > Flipping to the same FB_ID will result in a immediate flip as if it was
> > > > > changing to a different one, with no effect on the image but effecting
> > > > > the reported frame rate.
> > > > 
> > > > Re-setting FB_ID to its current value is a special case regardless of
> > > > PAGE_FLIP_ASYNC, is it not?
> > > 
> > > No. The rule has so far been that all side effects are observed
> > > even if you flip to the same fb. And that is one of my annoyances
> > > with this proposal. The rules will now be different for async flips
> > > vs. everything else.
> > 
> > Well with the patches the async page-flip case is exactly the same as
> > the non-async page-flip case. In both cases, if a FB_ID is included in
> > an atomic commit then the side effects are triggered even if the property
> > value didn't change. The rules are the same for everything.
> 
> I see it only checking if FB_ID changes or not. If it doesn't
> change then the implication is that the side effects will in
> fact be skipped as not all planes may even support async flips.

Hm right. So the problem is that setting any prop = same value as
previous one will result in a new page-flip for asynchronous page-flips,
but will not result in any side-effect for asynchronous page-flips.

Does it actually matter though? For async page-flips, I don't think this
would result in any actual difference in behavior?

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[Simon Ser]

On Monday, October 23rd, 2023 at 10:25, Simon Ser <contact@emersion.fr> wrote:

> > > > > > > > > > +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
> > > > > > > > > > +effectively change only the FB_ID property on any planes. No-operation changes
> > > > > > > > > > +are ignored as always. [...]
> > > > > > > > > > During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.
> > > > > > > > 
> > > > > > > > Xaver tested this hypothesis in a flipping the same fb in a VRR monitor
> > > > > > > > and it worked as expected, so this shouldn't be a concern.
> > > > > > > > Right, so it must have some effect. It cannot be simply ignored like in
> > > > > > > > the proposed doc wording. Do we special-case re-setting the same FB_ID
> > > > > > > > as "not a no-op" or "not ignored" or some other way?
> > > > > > > > There's an effect in the refresh rate, the image won't change but it
> > > > > > > > will report that a flip had happened asynchronously so the reported
> > > > > > > > framerate will be increased. Maybe an additional wording could be like:
> > > > > > 
> > > > > > Flipping to the same FB_ID will result in a immediate flip as if it was
> > > > > > changing to a different one, with no effect on the image but effecting
> > > > > > the reported frame rate.
> > > > > 
> > > > > Re-setting FB_ID to its current value is a special case regardless of
> > > > > PAGE_FLIP_ASYNC, is it not?
> > > > 
> > > > No. The rule has so far been that all side effects are observed
> > > > even if you flip to the same fb. And that is one of my annoyances
> > > > with this proposal. The rules will now be different for async flips
> > > > vs. everything else.
> > > 
> > > Well with the patches the async page-flip case is exactly the same as
> > > the non-async page-flip case. In both cases, if a FB_ID is included in
> > > an atomic commit then the side effects are triggered even if the property
> > > value didn't change. The rules are the same for everything.
> > 
> > I see it only checking if FB_ID changes or not. If it doesn't
> > change then the implication is that the side effects will in
> > fact be skipped as not all planes may even support async flips.
> 
> Hm right. So the problem is that setting any prop = same value as
> previous one will result in a new page-flip for asynchronous page-flips,
> but will not result in any side-effect for asynchronous page-flips.
> 
> Does it actually matter though? For async page-flips, I don't think this
> would result in any actual difference in behavior?

To sum this up, here is a matrix of behavior as seen by user-space:

- Sync atomic page-flip
  - Set FB_ID to different value: programs hw for page-flip, sends uevent
  - Set FB_ID to same value: same (important for VRR)
  - Set another plane prop to same value: same
  - Set another plane prop to different value: maybe rejected if modeset required
- Async atomic page-flip
  - Set FB_ID to different value: updates hw with new FB address, sends
    immediate uevent
  - Set FB_ID to same value: same (no-op for the hw)
  - Set another plane prop to same value: ignored, sends immediate uevent
    (special codepath)
  - Set another plane prop to different value: always rejected

To me sync and async look consistent.

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[Pekka Paalanen]

[-- Attachment #1: Type: text/plain, Size: 4159 bytes --]

On Mon, 13 Nov 2023 09:18:39 +0000
Simon Ser <contact@emersion.fr> wrote:

> On Monday, October 23rd, 2023 at 10:25, Simon Ser <contact@emersion.fr> wrote:
> 
> > > > > > > > > > > +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
> > > > > > > > > > > +effectively change only the FB_ID property on any planes. No-operation changes
> > > > > > > > > > > +are ignored as always. [...]
> > > > > > > > > > > During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.  
> > > > > > > > > 
> > > > > > > > > Xaver tested this hypothesis in a flipping the same fb in a VRR monitor
> > > > > > > > > and it worked as expected, so this shouldn't be a concern.
> > > > > > > > > Right, so it must have some effect. It cannot be simply ignored like in
> > > > > > > > > the proposed doc wording. Do we special-case re-setting the same FB_ID
> > > > > > > > > as "not a no-op" or "not ignored" or some other way?
> > > > > > > > > There's an effect in the refresh rate, the image won't change but it
> > > > > > > > > will report that a flip had happened asynchronously so the reported
> > > > > > > > > framerate will be increased. Maybe an additional wording could be like:  
> > > > > > > 
> > > > > > > Flipping to the same FB_ID will result in a immediate flip as if it was
> > > > > > > changing to a different one, with no effect on the image but effecting
> > > > > > > the reported frame rate.  
> > > > > > 
> > > > > > Re-setting FB_ID to its current value is a special case regardless of
> > > > > > PAGE_FLIP_ASYNC, is it not?  
> > > > > 
> > > > > No. The rule has so far been that all side effects are observed
> > > > > even if you flip to the same fb. And that is one of my annoyances
> > > > > with this proposal. The rules will now be different for async flips
> > > > > vs. everything else.  
> > > > 
> > > > Well with the patches the async page-flip case is exactly the same as
> > > > the non-async page-flip case. In both cases, if a FB_ID is included in
> > > > an atomic commit then the side effects are triggered even if the property
> > > > value didn't change. The rules are the same for everything.  
> > > 
> > > I see it only checking if FB_ID changes or not. If it doesn't
> > > change then the implication is that the side effects will in
> > > fact be skipped as not all planes may even support async flips.  
> > 
> > Hm right. So the problem is that setting any prop = same value as
> > previous one will result in a new page-flip for asynchronous page-flips,
> > but will not result in any side-effect for asynchronous page-flips.
> > 
> > Does it actually matter though? For async page-flips, I don't think this
> > would result in any actual difference in behavior?  

Hi Simon,

a fly-by question...

> To sum this up, here is a matrix of behavior as seen by user-space:
> 
> - Sync atomic page-flip
>   - Set FB_ID to different value: programs hw for page-flip, sends uevent
>   - Set FB_ID to same value: same (important for VRR)
>   - Set another plane prop to same value: same
>   - Set another plane prop to different value: maybe rejected if modeset required
> - Async atomic page-flip
>   - Set FB_ID to different value: updates hw with new FB address, sends
>     immediate uevent
>   - Set FB_ID to same value: same (no-op for the hw)

It should not be a no-op for the hw, because the hw might be in the
middle of a VRR front-porch waiting period, and the commit needs to end
the waiting immediately rather than time out?

>   - Set another plane prop to same value: ignored, sends immediate uevent
>     (special codepath)

If the sync case says "same", then shouldn't this say "same" as well to
be consistent?

>   - Set another plane prop to different value: always rejected
> 
> To me sync and async look consistent.


Thanks,
pq

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[Simon Ser]

On Monday, November 13th, 2023 at 10:38, Pekka Paalanen <ppaalanen@gmail.com> wrote:

> On Mon, 13 Nov 2023 09:18:39 +0000
> Simon Ser contact@emersion.fr wrote:
> 
> > On Monday, October 23rd, 2023 at 10:25, Simon Ser contact@emersion.fr wrote:
> > 
> > > > > > > > > > > > +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
> > > > > > > > > > > > +effectively change only the FB_ID property on any planes. No-operation changes
> > > > > > > > > > > > +are ignored as always. [...]
> > > > > > > > > > > > During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.
> > > > > > > > > > 
> > > > > > > > > > Xaver tested this hypothesis in a flipping the same fb in a VRR monitor
> > > > > > > > > > and it worked as expected, so this shouldn't be a concern.
> > > > > > > > > > Right, so it must have some effect. It cannot be simply ignored like in
> > > > > > > > > > the proposed doc wording. Do we special-case re-setting the same FB_ID
> > > > > > > > > > as "not a no-op" or "not ignored" or some other way?
> > > > > > > > > > There's an effect in the refresh rate, the image won't change but it
> > > > > > > > > > will report that a flip had happened asynchronously so the reported
> > > > > > > > > > framerate will be increased. Maybe an additional wording could be like:
> > > > > > > > 
> > > > > > > > Flipping to the same FB_ID will result in a immediate flip as if it was
> > > > > > > > changing to a different one, with no effect on the image but effecting
> > > > > > > > the reported frame rate.
> > > > > > > 
> > > > > > > Re-setting FB_ID to its current value is a special case regardless of
> > > > > > > PAGE_FLIP_ASYNC, is it not?
> > > > > > 
> > > > > > No. The rule has so far been that all side effects are observed
> > > > > > even if you flip to the same fb. And that is one of my annoyances
> > > > > > with this proposal. The rules will now be different for async flips
> > > > > > vs. everything else.
> > > > > 
> > > > > Well with the patches the async page-flip case is exactly the same as
> > > > > the non-async page-flip case. In both cases, if a FB_ID is included in
> > > > > an atomic commit then the side effects are triggered even if the property
> > > > > value didn't change. The rules are the same for everything.
> > > > 
> > > > I see it only checking if FB_ID changes or not. If it doesn't
> > > > change then the implication is that the side effects will in
> > > > fact be skipped as not all planes may even support async flips.
> > > 
> > > Hm right. So the problem is that setting any prop = same value as
> > > previous one will result in a new page-flip for asynchronous page-flips,
> > > but will not result in any side-effect for asynchronous page-flips.
> > > 
> > > Does it actually matter though? For async page-flips, I don't think this
> > > would result in any actual difference in behavior?
> 
> 
> Hi Simon,
> 
> a fly-by question...
> 
> > To sum this up, here is a matrix of behavior as seen by user-space:
> > 
> > - Sync atomic page-flip
> > - Set FB_ID to different value: programs hw for page-flip, sends uevent
> > - Set FB_ID to same value: same (important for VRR)
> > - Set another plane prop to same value: same
> > - Set another plane prop to different value: maybe rejected if modeset required
> > - Async atomic page-flip
> > - Set FB_ID to different value: updates hw with new FB address, sends
> > immediate uevent
> > - Set FB_ID to same value: same (no-op for the hw)
> 
> It should not be a no-op for the hw, because the hw might be in the
> middle of a VRR front-porch waiting period, and the commit needs to end
> the waiting immediately rather than time out?

I'm not sure 

> > - Set another plane prop to same value: ignored, sends immediate uevent
> > (special codepath)
> 
> If the sync case says "same", then shouldn't this say "same" as well to
> be consistent?

Okay, I think I chose my words badly. By "same" I meant "same as
previous item in the list".

Here I tried to be more explicit and explain why it's the same behavior.
We have a special path in the kernel code that ignores the change, but
the effective result is that it doesn't differ from the sync case.

Here's a fixed matrix where I don't use confusing words:

- Sync atomic page-flip
  - Set FB_ID to different value: programs hw for page-flip, sends uevent
  - Set FB_ID to same value: programs hw for page-flip, sends uevent (important
    for VRR)
  - Set another plane prop to same value: programs hw for page-flip, sends
    uevent
  - Set another plane prop to different value: maybe rejected if modeset required
- Async atomic page-flip
  - Set FB_ID to different value: updates hw with new FB address, sends
    immediate uevent
  - Set FB_ID to same value: updates hw with new FB address (no-op for the hw),
    sends immediate uevent
  - Set another plane prop to same value: ignored, sends immediate uevent
    (special codepath)
  - Set another plane prop to different value: always rejected

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[Pekka Paalanen]

[-- Attachment #1: Type: text/plain, Size: 6328 bytes --]

On Mon, 13 Nov 2023 09:44:15 +0000
Simon Ser <contact@emersion.fr> wrote:

> On Monday, November 13th, 2023 at 10:38, Pekka Paalanen <ppaalanen@gmail.com> wrote:
> 
> > On Mon, 13 Nov 2023 09:18:39 +0000
> > Simon Ser contact@emersion.fr wrote:
> >   
> > > On Monday, October 23rd, 2023 at 10:25, Simon Ser contact@emersion.fr wrote:
> > >   
> > > > > > > > > > > > > +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
> > > > > > > > > > > > > +effectively change only the FB_ID property on any planes. No-operation changes
> > > > > > > > > > > > > +are ignored as always. [...]
> > > > > > > > > > > > > During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.  
> > > > > > > > > > > 
> > > > > > > > > > > Xaver tested this hypothesis in a flipping the same fb in a VRR monitor
> > > > > > > > > > > and it worked as expected, so this shouldn't be a concern.
> > > > > > > > > > > Right, so it must have some effect. It cannot be simply ignored like in
> > > > > > > > > > > the proposed doc wording. Do we special-case re-setting the same FB_ID
> > > > > > > > > > > as "not a no-op" or "not ignored" or some other way?
> > > > > > > > > > > There's an effect in the refresh rate, the image won't change but it
> > > > > > > > > > > will report that a flip had happened asynchronously so the reported
> > > > > > > > > > > framerate will be increased. Maybe an additional wording could be like:  
> > > > > > > > > 
> > > > > > > > > Flipping to the same FB_ID will result in a immediate flip as if it was
> > > > > > > > > changing to a different one, with no effect on the image but effecting
> > > > > > > > > the reported frame rate.  
> > > > > > > > 
> > > > > > > > Re-setting FB_ID to its current value is a special case regardless of
> > > > > > > > PAGE_FLIP_ASYNC, is it not?  
> > > > > > > 
> > > > > > > No. The rule has so far been that all side effects are observed
> > > > > > > even if you flip to the same fb. And that is one of my annoyances
> > > > > > > with this proposal. The rules will now be different for async flips
> > > > > > > vs. everything else.  
> > > > > > 
> > > > > > Well with the patches the async page-flip case is exactly the same as
> > > > > > the non-async page-flip case. In both cases, if a FB_ID is included in
> > > > > > an atomic commit then the side effects are triggered even if the property
> > > > > > value didn't change. The rules are the same for everything.  
> > > > > 
> > > > > I see it only checking if FB_ID changes or not. If it doesn't
> > > > > change then the implication is that the side effects will in
> > > > > fact be skipped as not all planes may even support async flips.  
> > > > 
> > > > Hm right. So the problem is that setting any prop = same value as
> > > > previous one will result in a new page-flip for asynchronous page-flips,
> > > > but will not result in any side-effect for asynchronous page-flips.
> > > > 
> > > > Does it actually matter though? For async page-flips, I don't think this
> > > > would result in any actual difference in behavior?  
> > 
> > 
> > Hi Simon,
> > 
> > a fly-by question...
> >   
> > > To sum this up, here is a matrix of behavior as seen by user-space:
> > > 
> > > - Sync atomic page-flip
> > > - Set FB_ID to different value: programs hw for page-flip, sends uevent
> > > - Set FB_ID to same value: same (important for VRR)
> > > - Set another plane prop to same value: same
> > > - Set another plane prop to different value: maybe rejected if modeset required
> > > - Async atomic page-flip
> > > - Set FB_ID to different value: updates hw with new FB address, sends
> > > immediate uevent
> > > - Set FB_ID to same value: same (no-op for the hw)  
> > 
> > It should not be a no-op for the hw, because the hw might be in the
> > middle of a VRR front-porch waiting period, and the commit needs to end
> > the waiting immediately rather than time out?  
> 
> I'm not sure 

Would people not want to use async commits to trigger new VRR scanout
cycles without content updates?

I seem to recall previous comments that switching between sync and
async commit modes may take a moment (intel's one last sync flip), so
using sync once in a while then using async otherwise is probably not a
good idea.

> > > - Set another plane prop to same value: ignored, sends immediate uevent
> > > (special codepath)  
> > 
> > If the sync case says "same", then shouldn't this say "same" as well to
> > be consistent?  
> 
> Okay, I think I chose my words badly. By "same" I meant "same as
> previous item in the list".
> 
> Here I tried to be more explicit and explain why it's the same behavior.
> We have a special path in the kernel code that ignores the change, but
> the effective result is that it doesn't differ from the sync case.
> 
> Here's a fixed matrix where I don't use confusing words:
> 
> - Sync atomic page-flip
>   - Set FB_ID to different value: programs hw for page-flip, sends uevent
>   - Set FB_ID to same value: programs hw for page-flip, sends uevent (important
>     for VRR)
>   - Set another plane prop to same value: programs hw for page-flip, sends
>     uevent

Programming hw for page-flip probably triggers a new VRR scanout cycle,
even if the FB address didn't change.

>   - Set another plane prop to different value: maybe rejected if modeset required
> - Async atomic page-flip
>   - Set FB_ID to different value: updates hw with new FB address, sends
>     immediate uevent
>   - Set FB_ID to same value: updates hw with new FB address (no-op for the hw),
>     sends immediate uevent
>   - Set another plane prop to same value: ignored, sends immediate uevent
>     (special codepath)

Just like Michel points out: if this case has a special case ignoring
the set, then this case will not trigger a new VRR scanout cycle like
the corresponding sync case does.

>   - Set another plane prop to different value: always rejected


Thanks,
pq

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[Simon Ser]

On Monday, November 13th, 2023 at 11:15, Pekka Paalanen <ppaalanen@gmail.com> wrote:


> 
> 
> On Mon, 13 Nov 2023 09:44:15 +0000
> Simon Ser contact@emersion.fr wrote:
> 
> > On Monday, November 13th, 2023 at 10:38, Pekka Paalanen ppaalanen@gmail.com wrote:
> > 
> > > On Mon, 13 Nov 2023 09:18:39 +0000
> > > Simon Ser contact@emersion.fr wrote:
> > > 
> > > > On Monday, October 23rd, 2023 at 10:25, Simon Ser contact@emersion.fr wrote:
> > > > 
> > > > > > > > > > > > > > +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
> > > > > > > > > > > > > > +effectively change only the FB_ID property on any planes. No-operation changes
> > > > > > > > > > > > > > +are ignored as always. [...]
> > > > > > > > > > > > > > During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.
> > > > > > > > > > > > 
> > > > > > > > > > > > Xaver tested this hypothesis in a flipping the same fb in a VRR monitor
> > > > > > > > > > > > and it worked as expected, so this shouldn't be a concern.
> > > > > > > > > > > > Right, so it must have some effect. It cannot be simply ignored like in
> > > > > > > > > > > > the proposed doc wording. Do we special-case re-setting the same FB_ID
> > > > > > > > > > > > as "not a no-op" or "not ignored" or some other way?
> > > > > > > > > > > > There's an effect in the refresh rate, the image won't change but it
> > > > > > > > > > > > will report that a flip had happened asynchronously so the reported
> > > > > > > > > > > > framerate will be increased. Maybe an additional wording could be like:
> > > > > > > > > > 
> > > > > > > > > > Flipping to the same FB_ID will result in a immediate flip as if it was
> > > > > > > > > > changing to a different one, with no effect on the image but effecting
> > > > > > > > > > the reported frame rate.
> > > > > > > > > 
> > > > > > > > > Re-setting FB_ID to its current value is a special case regardless of
> > > > > > > > > PAGE_FLIP_ASYNC, is it not?
> > > > > > > > 
> > > > > > > > No. The rule has so far been that all side effects are observed
> > > > > > > > even if you flip to the same fb. And that is one of my annoyances
> > > > > > > > with this proposal. The rules will now be different for async flips
> > > > > > > > vs. everything else.
> > > > > > > 
> > > > > > > Well with the patches the async page-flip case is exactly the same as
> > > > > > > the non-async page-flip case. In both cases, if a FB_ID is included in
> > > > > > > an atomic commit then the side effects are triggered even if the property
> > > > > > > value didn't change. The rules are the same for everything.
> > > > > > 
> > > > > > I see it only checking if FB_ID changes or not. If it doesn't
> > > > > > change then the implication is that the side effects will in
> > > > > > fact be skipped as not all planes may even support async flips.
> > > > > 
> > > > > Hm right. So the problem is that setting any prop = same value as
> > > > > previous one will result in a new page-flip for asynchronous page-flips,
> > > > > but will not result in any side-effect for asynchronous page-flips.
> > > > > 
> > > > > Does it actually matter though? For async page-flips, I don't think this
> > > > > would result in any actual difference in behavior?
> > > 
> > > Hi Simon,
> > > 
> > > a fly-by question...
> > > 
> > > > To sum this up, here is a matrix of behavior as seen by user-space:
> > > > 
> > > > - Sync atomic page-flip
> > > > - Set FB_ID to different value: programs hw for page-flip, sends uevent
> > > > - Set FB_ID to same value: same (important for VRR)
> > > > - Set another plane prop to same value: same
> > > > - Set another plane prop to different value: maybe rejected if modeset required
> > > > - Async atomic page-flip
> > > > - Set FB_ID to different value: updates hw with new FB address, sends
> > > > immediate uevent
> > > > - Set FB_ID to same value: same (no-op for the hw)
> > > 
> > > It should not be a no-op for the hw, because the hw might be in the
> > > middle of a VRR front-porch waiting period, and the commit needs to end
> > > the waiting immediately rather than time out?
> > 
> > I'm not sure
> 
> Would people not want to use async commits to trigger new VRR scanout
> cycles without content updates?
> 
> I seem to recall previous comments that switching between sync and
> async commit modes may take a moment (intel's one last sync flip), so
> using sync once in a while then using async otherwise is probably not a
> good idea.

Sorry, my line got cut off. I meant: "I'm not sure what you mean".

> > > > - Set another plane prop to same value: ignored, sends immediate uevent
> > > > (special codepath)
> > > 
> > > If the sync case says "same", then shouldn't this say "same" as well to
> > > be consistent?
> > 
> > Okay, I think I chose my words badly. By "same" I meant "same as
> > previous item in the list".
> > 
> > Here I tried to be more explicit and explain why it's the same behavior.
> > We have a special path in the kernel code that ignores the change, but
> > the effective result is that it doesn't differ from the sync case.
> > 
> > Here's a fixed matrix where I don't use confusing words:
> > 
> > - Sync atomic page-flip
> > - Set FB_ID to different value: programs hw for page-flip, sends uevent
> > - Set FB_ID to same value: programs hw for page-flip, sends uevent (important
> > for VRR)
> > - Set another plane prop to same value: programs hw for page-flip, sends
> > uevent
> 
> Programming hw for page-flip probably triggers a new VRR scanout cycle,
> even if the FB address didn't change.
> 
> > - Set another plane prop to different value: maybe rejected if modeset required
> > - Async atomic page-flip
> > - Set FB_ID to different value: updates hw with new FB address, sends
> > immediate uevent
> > - Set FB_ID to same value: updates hw with new FB address (no-op for the hw),
> > sends immediate uevent
> > - Set another plane prop to same value: ignored, sends immediate uevent
> > (special codepath)
> 
> Just like Michel points out: if this case has a special case ignoring
> the set, then this case will not trigger a new VRR scanout cycle like
> the corresponding sync case does.

Ignore the prop change, but still include the CRTC in the commit, so
everything is fine.

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[Michel Dänzer]

On 11/13/23 10:18, Simon Ser wrote:
> On Monday, October 23rd, 2023 at 10:25, Simon Ser <contact@emersion.fr> wrote:
> 
>>>>>>>>>>> +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
>>>>>>>>>>> +effectively change only the FB_ID property on any planes. No-operation changes
>>>>>>>>>>> +are ignored as always. [...]
>>>>>>>>>>> During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.
>>>>>>>>>
>>>>>>>>> Xaver tested this hypothesis in a flipping the same fb in a VRR monitor
>>>>>>>>> and it worked as expected, so this shouldn't be a concern.
>>>>>>>>> Right, so it must have some effect. It cannot be simply ignored like in
>>>>>>>>> the proposed doc wording. Do we special-case re-setting the same FB_ID
>>>>>>>>> as "not a no-op" or "not ignored" or some other way?
>>>>>>>>> There's an effect in the refresh rate, the image won't change but it
>>>>>>>>> will report that a flip had happened asynchronously so the reported
>>>>>>>>> framerate will be increased. Maybe an additional wording could be like:
>>>>>>>
>>>>>>> Flipping to the same FB_ID will result in a immediate flip as if it was
>>>>>>> changing to a different one, with no effect on the image but effecting
>>>>>>> the reported frame rate.
>>>>>>
>>>>>> Re-setting FB_ID to its current value is a special case regardless of
>>>>>> PAGE_FLIP_ASYNC, is it not?
>>>>>
>>>>> No. The rule has so far been that all side effects are observed
>>>>> even if you flip to the same fb. And that is one of my annoyances
>>>>> with this proposal. The rules will now be different for async flips
>>>>> vs. everything else.
>>>>
>>>> Well with the patches the async page-flip case is exactly the same as
>>>> the non-async page-flip case. In both cases, if a FB_ID is included in
>>>> an atomic commit then the side effects are triggered even if the property
>>>> value didn't change. The rules are the same for everything.
>>>
>>> I see it only checking if FB_ID changes or not. If it doesn't
>>> change then the implication is that the side effects will in
>>> fact be skipped as not all planes may even support async flips.
>>
>> Hm right. So the problem is that setting any prop = same value as
>> previous one will result in a new page-flip for asynchronous page-flips,
>> but will not result in any side-effect for asynchronous page-flips.
>>
>> Does it actually matter though? For async page-flips, I don't think this
>> would result in any actual difference in behavior?
> 
> To sum this up, here is a matrix of behavior as seen by user-space:
> 
> - Sync atomic page-flip
>   - Set FB_ID to different value: programs hw for page-flip, sends uevent
>   - Set FB_ID to same value: same (important for VRR)
>   - Set another plane prop to same value: same

A page flip is programmed even if FB_ID isn't touched?


>   - Set another plane prop to different value: maybe rejected if modeset required
> - Async atomic page-flip
>   - Set FB_ID to different value: updates hw with new FB address, sends
>     immediate uevent
>   - Set FB_ID to same value: same (no-op for the hw)

No-op implies it doesn't trigger scanning out a frame with VRR, if scanout is currently in vertical blank. Is that the case? If so, async flips can't reliably trigger scanning out a frame with VRR.


-- 
Earthling Michel Dänzer            |                  https://redhat.com
Libre software enthusiast          |         Mesa and Xwayland developer

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[Simon Ser]

On Monday, November 13th, 2023 at 10:41, Michel Dänzer <michel.daenzer@mailbox.org> wrote:

> On 11/13/23 10:18, Simon Ser wrote:
> 
> > On Monday, October 23rd, 2023 at 10:25, Simon Ser contact@emersion.fr wrote:
> > 
> > > > > > > > > > > > +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
> > > > > > > > > > > > +effectively change only the FB_ID property on any planes. No-operation changes
> > > > > > > > > > > > +are ignored as always. [...]
> > > > > > > > > > > > During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.
> > > > > > > > > > 
> > > > > > > > > > Xaver tested this hypothesis in a flipping the same fb in a VRR monitor
> > > > > > > > > > and it worked as expected, so this shouldn't be a concern.
> > > > > > > > > > Right, so it must have some effect. It cannot be simply ignored like in
> > > > > > > > > > the proposed doc wording. Do we special-case re-setting the same FB_ID
> > > > > > > > > > as "not a no-op" or "not ignored" or some other way?
> > > > > > > > > > There's an effect in the refresh rate, the image won't change but it
> > > > > > > > > > will report that a flip had happened asynchronously so the reported
> > > > > > > > > > framerate will be increased. Maybe an additional wording could be like:
> > > > > > > > 
> > > > > > > > Flipping to the same FB_ID will result in a immediate flip as if it was
> > > > > > > > changing to a different one, with no effect on the image but effecting
> > > > > > > > the reported frame rate.
> > > > > > > 
> > > > > > > Re-setting FB_ID to its current value is a special case regardless of
> > > > > > > PAGE_FLIP_ASYNC, is it not?
> > > > > > 
> > > > > > No. The rule has so far been that all side effects are observed
> > > > > > even if you flip to the same fb. And that is one of my annoyances
> > > > > > with this proposal. The rules will now be different for async flips
> > > > > > vs. everything else.
> > > > > 
> > > > > Well with the patches the async page-flip case is exactly the same as
> > > > > the non-async page-flip case. In both cases, if a FB_ID is included in
> > > > > an atomic commit then the side effects are triggered even if the property
> > > > > value didn't change. The rules are the same for everything.
> > > > 
> > > > I see it only checking if FB_ID changes or not. If it doesn't
> > > > change then the implication is that the side effects will in
> > > > fact be skipped as not all planes may even support async flips.
> > > 
> > > Hm right. So the problem is that setting any prop = same value as
> > > previous one will result in a new page-flip for asynchronous page-flips,
> > > but will not result in any side-effect for asynchronous page-flips.
> > > 
> > > Does it actually matter though? For async page-flips, I don't think this
> > > would result in any actual difference in behavior?
> > 
> > To sum this up, here is a matrix of behavior as seen by user-space:
> > 
> > - Sync atomic page-flip
> > - Set FB_ID to different value: programs hw for page-flip, sends uevent
> > - Set FB_ID to same value: same (important for VRR)
> > - Set another plane prop to same value: same
> 
> A page flip is programmed even if FB_ID isn't touched?

I believe so. Set CRTC_X on a plane to the same value as before, and the
CRTC gets implicitly included in the atomic commit?

> > - Set another plane prop to different value: maybe rejected if modeset required
> > - Async atomic page-flip
> > - Set FB_ID to different value: updates hw with new FB address, sends
> > immediate uevent
> > - Set FB_ID to same value: same (no-op for the hw)
> 
> No-op implies it doesn't trigger scanning out a frame with VRR, if
> scanout is currently in vertical blank. Is that the case? If so, async
> flips can't reliably trigger scanning out a frame with VRR.

By no-op I mean that the hw is programmed for an immediate async flip
with the same buffer addr as the previous one. So this doesn't actually
change anything.

Re: [PATCH v6 6/6] drm/doc: Define KMS atomic state set

[Michel Dänzer]

On 11/13/23 10:47, Simon Ser wrote:
> On Monday, November 13th, 2023 at 10:41, Michel Dänzer <michel.daenzer@mailbox.org> wrote:
> 
>> On 11/13/23 10:18, Simon Ser wrote:
>>
>>> On Monday, October 23rd, 2023 at 10:25, Simon Ser contact@emersion.fr wrote:
>>>
>>>>>>>>>>>>> +An atomic commit with the flag DRM_MODE_PAGE_FLIP_ASYNC is allowed to
>>>>>>>>>>>>> +effectively change only the FB_ID property on any planes. No-operation changes
>>>>>>>>>>>>> +are ignored as always. [...]
>>>>>>>>>>>>> During the hackfest in Brno, it was mentioned that a commit which re-sets the same FB_ID could actually have an effect with VRR: It could trigger scanout of the next frame before vertical blank has reached its maximum duration. Some kind of mechanism is required for this in order to allow user space to perform low frame rate compensation.
>>>>>>>>>>>
>>>>>>>>>>> Xaver tested this hypothesis in a flipping the same fb in a VRR monitor
>>>>>>>>>>> and it worked as expected, so this shouldn't be a concern.
>>>>>>>>>>> Right, so it must have some effect. It cannot be simply ignored like in
>>>>>>>>>>> the proposed doc wording. Do we special-case re-setting the same FB_ID
>>>>>>>>>>> as "not a no-op" or "not ignored" or some other way?
>>>>>>>>>>> There's an effect in the refresh rate, the image won't change but it
>>>>>>>>>>> will report that a flip had happened asynchronously so the reported
>>>>>>>>>>> framerate will be increased. Maybe an additional wording could be like:
>>>>>>>>>
>>>>>>>>> Flipping to the same FB_ID will result in a immediate flip as if it was
>>>>>>>>> changing to a different one, with no effect on the image but effecting
>>>>>>>>> the reported frame rate.
>>>>>>>>
>>>>>>>> Re-setting FB_ID to its current value is a special case regardless of
>>>>>>>> PAGE_FLIP_ASYNC, is it not?
>>>>>>>
>>>>>>> No. The rule has so far been that all side effects are observed
>>>>>>> even if you flip to the same fb. And that is one of my annoyances
>>>>>>> with this proposal. The rules will now be different for async flips
>>>>>>> vs. everything else.
>>>>>>
>>>>>> Well with the patches the async page-flip case is exactly the same as
>>>>>> the non-async page-flip case. In both cases, if a FB_ID is included in
>>>>>> an atomic commit then the side effects are triggered even if the property
>>>>>> value didn't change. The rules are the same for everything.
>>>>>
>>>>> I see it only checking if FB_ID changes or not. If it doesn't
>>>>> change then the implication is that the side effects will in
>>>>> fact be skipped as not all planes may even support async flips.
>>>>
>>>> Hm right. So the problem is that setting any prop = same value as
>>>> previous one will result in a new page-flip for asynchronous page-flips,
>>>> but will not result in any side-effect for asynchronous page-flips.
>>>>
>>>> Does it actually matter though? For async page-flips, I don't think this
>>>> would result in any actual difference in behavior?
>>>
>>> To sum this up, here is a matrix of behavior as seen by user-space:
>>>
>>> - Sync atomic page-flip
>>> - Set FB_ID to different value: programs hw for page-flip, sends uevent
>>> - Set FB_ID to same value: same (important for VRR)
>>> - Set another plane prop to same value: same
>>
>> A page flip is programmed even if FB_ID isn't touched?
> 
> I believe so. Set CRTC_X on a plane to the same value as before, and the
> CRTC gets implicitly included in the atomic commit?
> 
>>> - Set another plane prop to different value: maybe rejected if modeset required
>>> - Async atomic page-flip
>>> - Set FB_ID to different value: updates hw with new FB address, sends
>>> immediate uevent
>>> - Set FB_ID to same value: same (no-op for the hw)
>>
>> No-op implies it doesn't trigger scanning out a frame with VRR, if
>> scanout is currently in vertical blank. Is that the case? If so, async
>> flips can't reliably trigger scanning out a frame with VRR.
> 
> By no-op I mean that the hw is programmed for an immediate async flip
> with the same buffer addr as the previous one. So this doesn't actually
> change anything.

If a flip is programmed to the HW, it's not a no-op any more than in the sync case, in particular not with VRR.


-- 
Earthling Michel Dänzer            |                  https://redhat.com
Libre software enthusiast          |         Mesa and Xwayland developer