diff options
Diffstat (limited to 'SOURCES/valve-gamescope-framerate-control-fixups.patch')
| -rw-r--r-- | SOURCES/valve-gamescope-framerate-control-fixups.patch | 647 |
1 files changed, 647 insertions, 0 deletions
diff --git a/SOURCES/valve-gamescope-framerate-control-fixups.patch b/SOURCES/valve-gamescope-framerate-control-fixups.patch new file mode 100644 index 0000000..425ee09 --- /dev/null +++ b/SOURCES/valve-gamescope-framerate-control-fixups.patch @@ -0,0 +1,647 @@ +From 79f7b70729663c5986c84e1a0888f50a55a81093 Mon Sep 17 00:00:00 2001 +From: Thomas Crider <gloriouseggroll@gmail.com> +Date: Mon, 18 Dec 2023 03:36:09 -0500 +Subject: [PATCH 1/6] revert 1101185bc50f5e45b8b89300914d9aa35a0c8cbe + +--- + drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +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 7dab01803..81672738a 100644 +--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c ++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +@@ -6106,6 +6106,8 @@ create_stream_for_sink(struct amdgpu_dm_connector *aconnector, + + if (recalculate_timing) + drm_mode_set_crtcinfo(&saved_mode, 0); ++ else if (!old_stream) ++ drm_mode_set_crtcinfo(&mode, 0); + + /* + * If scaling is enabled and refresh rate didn't change +@@ -6669,8 +6671,6 @@ enum drm_mode_status amdgpu_dm_connector_mode_valid(struct drm_connector *connec + goto fail; + } + +- drm_mode_set_crtcinfo(mode, 0); +- + stream = create_validate_stream_for_sink(aconnector, mode, + to_dm_connector_state(connector->state), + NULL); +-- +2.43.0 + +From 38f2149c7e97f379210c658c21124d547e7b503a Mon Sep 17 00:00:00 2001 +From: Simon Ser <contact@emersion.fr> +Date: Tue, 30 Aug 2022 17:29:43 +0000 +Subject: [PATCH] drm: introduce DRM_CAP_ATOMIC_ASYNC_PAGE_FLIP +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +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> +Cc: Daniel Vetter <daniel.vetter@ffwll.ch> +Cc: Joshua Ashton <joshua@froggi.es> +Cc: Melissa Wen <mwen@igalia.com> +Cc: Alex Deucher <alexander.deucher@amd.com> +Cc: Harry Wentland <hwentlan@amd.com> +Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com> +Cc: André Almeida <andrealmeid@igalia.com> +Cc: Ville Syrjälä <ville.syrjala@linux.intel.com> +Signed-off-by: Cristian Ciocaltea <cristian.ciocaltea@collabora.com> +Link: https://lore.kernel.org/r/20220830172851.269402-6-contact@emersion.fr +--- + 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 ca2a6e6101dc8..5b1591e2b46c9 100644 +--- a/drivers/gpu/drm/drm_ioctl.c ++++ b/drivers/gpu/drm/drm_ioctl.c +@@ -302,6 +302,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 642808520d922..b1962628ecda9 100644 +--- a/include/uapi/drm/drm.h ++++ b/include/uapi/drm/drm.h +@@ -706,7 +706,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 +773,13 @@ + * :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 { +-- +GitLab + +From f6de551227de6244119f9f2bea3ae81543ee7c4f Mon Sep 17 00:00:00 2001 +From: Simon Ser <contact@emersion.fr> +Date: Tue, 30 Aug 2022 17:29:35 +0000 +Subject: [PATCH] drm: allow DRM_MODE_PAGE_FLIP_ASYNC for atomic commits +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +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. + +v2: document new uAPI + +Signed-off-by: Simon Ser <contact@emersion.fr> +Co-developed-by: André Almeida <andrealmeid@igalia.com> +Signed-off-by: André Almeida <andrealmeid@igalia.com> +Cc: Daniel Vetter <daniel.vetter@ffwll.ch> +Cc: Joshua Ashton <joshua@froggi.es> +Cc: Melissa Wen <mwen@igalia.com> +Cc: Alex Deucher <alexander.deucher@amd.com> +Cc: Harry Wentland <hwentlan@amd.com> +Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com> +Cc: Ville Syrjälä <ville.syrjala@linux.intel.com> +Signed-off-by: Cristian Ciocaltea <cristian.ciocaltea@collabora.com> +Link: https://lore.kernel.org/r/20220830172851.269402-5-contact@emersion.fr +--- + drivers/gpu/drm/drm_atomic_uapi.c | 28 +++++++++++++++++++++++++--- + include/uapi/drm/drm_mode.h | 4 ++++ + 2 files changed, 29 insertions(+), 3 deletions(-) + +diff --git a/drivers/gpu/drm/drm_atomic_uapi.c b/drivers/gpu/drm/drm_atomic_uapi.c +index c06d0639d552d..945761968428e 100644 +--- a/drivers/gpu/drm/drm_atomic_uapi.c ++++ b/drivers/gpu/drm/drm_atomic_uapi.c +@@ -1282,6 +1282,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) + { +@@ -1322,9 +1334,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. */ +@@ -1422,6 +1441,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 46becedf5b2fc..f1422c8387224 100644 +--- a/include/uapi/drm/drm_mode.h ++++ b/include/uapi/drm/drm_mode.h +@@ -949,6 +949,10 @@ 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. + */ + #define DRM_MODE_PAGE_FLIP_ASYNC 0x02 + #define DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE 0x4 +-- +GitLab + +From 9d923e79d060d8c7218c8229c65c964b7f04e864 Mon Sep 17 00:00:00 2001 +From: Simon Ser <contact@emersion.fr> +Date: Tue, 30 Aug 2022 17:29:26 +0000 +Subject: [PATCH] drm: introduce + drm_mode_config.atomic_async_page_flip_not_supported +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +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. + +v2: only set the flag on atomic drivers (remove it on amdgpu DCE and +on radeon) + +Signed-off-by: Simon Ser <contact@emersion.fr> +Cc: Daniel Vetter <daniel.vetter@ffwll.ch> +Cc: Joshua Ashton <joshua@froggi.es> +Cc: Melissa Wen <mwen@igalia.com> +Cc: Alex Deucher <alexander.deucher@amd.com> +Cc: Harry Wentland <hwentlan@amd.com> +Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com> +Cc: André Almeida <andrealmeid@igalia.com> +Cc: Ville Syrjälä <ville.syrjala@linux.intel.com> +Signed-off-by: Cristian Ciocaltea <cristian.ciocaltea@collabora.com> +Link: https://lore.kernel.org/r/20220830172851.269402-4-contact@emersion.fr +--- + 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 + + drivers/gpu/drm/vc4/vc4_kms.c | 1 + + include/drm/drm_mode_config.h | 11 +++++++++++ + 6 files changed, 16 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 81672738a..05c404fcc 100644 +--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c ++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +@@ -3998,6 +3998,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 fa0f9a93d..301b222c4 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 8f144d4d3..f290c5c2e 100644 +--- a/drivers/gpu/drm/i915/display/intel_display_driver.c ++++ b/drivers/gpu/drm/i915/display/intel_display_driver.c +@@ -126,6 +126,7 @@ + mode_config->helper_private = &intel_mode_config_funcs; + + mode_config->async_page_flip = HAS_ASYNC_FLIPS(i915) && !i915->params.disable_async_page_flip; ++ 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 99977e5fe..540895dab 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/drivers/gpu/drm/vc4/vc4_kms.c b/drivers/gpu/drm/vc4/vc4_kms.c +index 5495f2a94..5b6b311e7 100644 +--- a/drivers/gpu/drm/vc4/vc4_kms.c ++++ b/drivers/gpu/drm/vc4/vc4_kms.c +@@ -1068,6 +1068,7 @@ int vc4_kms_load(struct drm_device *dev) + dev->mode_config.helper_private = &vc4_mode_config_helpers; + dev->mode_config.preferred_depth = 24; + dev->mode_config.async_page_flip = true; ++ dev->mode_config.atomic_async_page_flip_not_supported = true; + dev->mode_config.normalize_zpos = true; + + ret = vc4_ctm_obj_init(vc4); +diff --git a/include/drm/drm_mode_config.h b/include/drm/drm_mode_config.h +index 973119a91..47b005671 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.43.0 + +From 24ac301d6208f1135644fe32514994799e79a6a0 Mon Sep 17 00:00:00 2001 +From: Simon Ser <contact@emersion.fr> +Date: Tue, 30 Aug 2022 17:29:52 +0000 +Subject: [PATCH] amd/display: indicate support for atomic async page-flips on + DC +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +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. + +v2: make it clear this commit is about DC and not only DCN + +Signed-off-by: Simon Ser <contact@emersion.fr> +Cc: Joshua Ashton <joshua@froggi.es> +Cc: Melissa Wen <mwen@igalia.com> +Cc: Alex Deucher <alexander.deucher@amd.com> +Cc: Harry Wentland <hwentlan@amd.com> +Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com> +Cc: André Almeida <andrealmeid@igalia.com> +Signed-off-by: Cristian Ciocaltea <cristian.ciocaltea@collabora.com> +Link: https://lore.kernel.org/r/20220830172851.269402-7-contact@emersion.fr +--- + 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 27a1e3a0046c9..a003e796aa183 100644 +--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c ++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +@@ -3980,7 +3980,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) +-- +GitLab + +From 32993fef83542e3bea66ed3ceec4944b3ae9d4f1 Mon Sep 17 00:00:00 2001 +From: Joshua Ashton <joshua@froggi.es> +Date: Mon, 14 Nov 2022 19:52:30 +0000 +Subject: [PATCH] drm/amd/display: Always set crtcinfo from + create_stream_for_sink + +Given that we always pass dm_state into here now, this won't ever +trigger anymore. + +This is needed for we will always fail mode validation with invalid +clocks or link bandwidth errors. + +Signed-off-by: Joshua Ashton <joshua@froggi.es> +Signed-off-by: Harry Wentland <harry.wentland@amd.com> +Reviewed-by: Harry Wentland <harry.wentland@amd.com> + +Cc: Pekka Paalanen <ppaalanen@gmail.com> +Cc: Sebastian Wick <sebastian.wick@redhat.com> +Cc: Vitaly.Prosyak@amd.com +Cc: Joshua Ashton <joshua@froggi.es> +Cc: Simon Ser <contact@emersion.fr> +Cc: Melissa Wen <mwen@igalia.com> +Cc: dri-devel@lists.freedesktop.org +Cc: amd-gfx@lists.freedesktop.org +Signed-off-by: Alex Deucher <alexander.deucher@amd.com> +--- + drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c | 2 +- + 1 file changed, 1 insertion(+), 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 81672738a..8eb14c74a 100644 +--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c ++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +@@ -6106,7 +6106,7 @@ create_stream_for_sink(struct amdgpu_dm_connector *aconnector, + + if (recalculate_timing) + drm_mode_set_crtcinfo(&saved_mode, 0); +- else if (!old_stream) ++ else + drm_mode_set_crtcinfo(&mode, 0); + + /* +-- +2.43.0 + +From 0af59135c2a9e05af87bc82f492fab13fff52fbd Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Andr=C3=A9=20Almeida?= <andrealmeid@igalia.com> +Date: Wed, 22 Nov 2023 13:19:38 -0300 +Subject: [PATCH] drm: Refuse to async flip with atomic prop changes +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +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 exception is the framebuffer ID to flip +to. Currently the only plane type supported is the primary one. + +Signed-off-by: André Almeida <andrealmeid@igalia.com> +Reviewed-by: Simon Ser <contact@emersion.fr> +--- + drivers/gpu/drm/drm_atomic_uapi.c | 52 +++++++++++++++++++++++++++-- + drivers/gpu/drm/drm_crtc_internal.h | 2 +- + drivers/gpu/drm/drm_mode_object.c | 2 +- + 3 files changed, 51 insertions(+), 5 deletions(-) + +diff --git a/drivers/gpu/drm/drm_atomic_uapi.c b/drivers/gpu/drm/drm_atomic_uapi.c +index 37caa6c33e22b3..86083184ac6bb2 100644 +--- a/drivers/gpu/drm/drm_atomic_uapi.c ++++ b/drivers/gpu/drm/drm_atomic_uapi.c +@@ -964,13 +964,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)) +@@ -987,6 +1002,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); +@@ -1002,6 +1024,13 @@ int drm_atomic_set_property(struct drm_atomic_state *state, + break; + } + ++ if (async_flip) { ++ 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; +@@ -1009,6 +1038,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)) { +@@ -1016,6 +1046,21 @@ 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; ++ } ++ ++ if (async_flip && plane_state->plane->type != DRM_PLANE_TYPE_PRIMARY) { ++ drm_dbg_atomic(prop->dev, ++ "[OBJECT:%d] Only primary planes can be changed during async flip\n", ++ obj->id); ++ ret = -EINVAL; ++ break; ++ } ++ + ret = drm_atomic_plane_set_property(plane, + plane_state, file_priv, + prop, prop_value); +@@ -1295,6 +1340,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)) +@@ -1408,8 +1454,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 501a10edd0e1dc..381130cebe811c 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 ac0d2ce3f87041..0e8355063eee36 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); +From 1edf3fbbeb36440e1222c2fe0e8127fb804c5278 Mon Sep 17 00:00:00 2001 +From: Hamza Mahfooz <hamza.mahfooz@amd.com> +Date: Fri, 4 Aug 2023 11:13:04 -0400 +Subject: [PATCH] drm/amd/display: ensure async flips are only accepted for + fast updates + +We should be checking to see if async flips are supported in +amdgpu_dm_atomic_check() (i.e. not dm_crtc_helper_atomic_check()). Also, +async flipping isn't supported if a plane's framebuffer changes memory +domains during an atomic commit. So, move the check from +dm_crtc_helper_atomic_check() to amdgpu_dm_atomic_check() and check if +the memory domain has changed in amdgpu_dm_atomic_check(). + +Cc: stable@vger.kernel.org +Link: https://gitlab.freedesktop.org/drm/amd/-/issues/2733 +Fixes: c1e18c44dc7f ("drm/amd/display: only accept async flips for fast updates") +Reviewed-by: Harry Wentland <harry.wentland@amd.com> +Signed-off-by: Hamza Mahfooz <hamza.mahfooz@amd.com> +Signed-off-by: Alex Deucher <alexander.deucher@amd.com> +(cherry picked from commit a7c0cad0dc060bb77e9c9d235d68441b0fc69507) +Signed-off-by: Cristian Ciocaltea <cristian.ciocaltea@collabora.com> +--- + .../gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crtc.c | 12 ------------ + 1 file changed, 12 deletions(-) + +diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crtc.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crtc.c +index be1ebe826442a4..4b223db0cf2fe8 100644 +--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crtc.c ++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crtc.c +@@ -473,18 +473,6 @@ static int dm_crtc_helper_atomic_check(struct drm_crtc *crtc, + return -EINVAL; + } + +- /* +- * Only allow async flips for fast updates that don't change the FB +- * pitch, the DCC state, rotation, etc. +- */ +- if (crtc_state->async_flip && +- dm_crtc_state->update_type != UPDATE_TYPE_FAST) { +- drm_dbg_atomic(crtc->dev, +- "[CRTC:%d:%s] async flips are only supported for fast updates\n", +- crtc->base.id, crtc->name); +- return -EINVAL; +- } +- + /* In some use cases, like reset, no stream is attached */ + if (!dm_crtc_state->stream) + return 0; |