aboutsummaryrefslogtreecommitdiffstats
path: root/target/linux/bcm27xx/patches-5.15/950-0008-drm-vc4-hdmi-Use-a-mutex-to-prevent-concurrent-frame.patch
diff options
context:
space:
mode:
Diffstat (limited to 'target/linux/bcm27xx/patches-5.15/950-0008-drm-vc4-hdmi-Use-a-mutex-to-prevent-concurrent-frame.patch')
-rw-r--r--target/linux/bcm27xx/patches-5.15/950-0008-drm-vc4-hdmi-Use-a-mutex-to-prevent-concurrent-frame.patch444
1 files changed, 444 insertions, 0 deletions
diff --git a/target/linux/bcm27xx/patches-5.15/950-0008-drm-vc4-hdmi-Use-a-mutex-to-prevent-concurrent-frame.patch b/target/linux/bcm27xx/patches-5.15/950-0008-drm-vc4-hdmi-Use-a-mutex-to-prevent-concurrent-frame.patch
new file mode 100644
index 0000000000..2298c0d812
--- /dev/null
+++ b/target/linux/bcm27xx/patches-5.15/950-0008-drm-vc4-hdmi-Use-a-mutex-to-prevent-concurrent-frame.patch
@@ -0,0 +1,444 @@
+From 5976ef1d81c8d474eddb55103f29a686f84f22f1 Mon Sep 17 00:00:00 2001
+From: Maxime Ripard <maxime@cerno.tech>
+Date: Mon, 25 Oct 2021 16:11:09 +0200
+Subject: [PATCH] drm/vc4: hdmi: Use a mutex to prevent concurrent
+ framework access
+
+The vc4 HDMI controller registers into the KMS, CEC and ALSA
+frameworks.
+
+However, no particular care is done to prevent the concurrent execution
+of different framework hooks from happening at the same time.
+
+In order to protect against that scenario, let's introduce a mutex that
+relevant ALSA and KMS hooks will need to take to prevent concurrent
+execution.
+
+CEC is left out at the moment though, since the .get_modes and .detect
+KMS hooks, when running cec_s_phys_addr_from_edid, can end up calling
+CEC's .adap_enable hook. This introduces some reentrancy that isn't easy
+to deal with properly.
+
+The CEC hooks also don't share much state with the rest of the driver:
+the registers are entirely separate, we don't share any variable, the
+only thing that can conflict is the CEC clock divider setup that can be
+affected by a mode set.
+
+However, after discussing it, it looks like CEC should be able to
+recover from this if it was to happen.
+
+Link: https://lore.kernel.org/r/20211025141113.702757-6-maxime@cerno.tech
+Fixes: bb7d78568814 ("drm/vc4: Add HDMI audio support")
+Acked-by: Daniel Vetter <daniel.vetter@ffwll.ch>
+Signed-off-by: Maxime Ripard <maxime@cerno.tech>
+---
+ drivers/gpu/drm/vc4/vc4_hdmi.c | 118 +++++++++++++++++++++++++++++++--
+ drivers/gpu/drm/vc4/vc4_hdmi.h | 14 ++++
+ 2 files changed, 126 insertions(+), 6 deletions(-)
+
+--- a/drivers/gpu/drm/vc4/vc4_hdmi.c
++++ b/drivers/gpu/drm/vc4/vc4_hdmi.c
+@@ -188,6 +188,8 @@ vc4_hdmi_connector_detect(struct drm_con
+ struct vc4_hdmi *vc4_hdmi = connector_to_vc4_hdmi(connector);
+ bool connected = false;
+
++ mutex_lock(&vc4_hdmi->mutex);
++
+ WARN_ON(pm_runtime_resume_and_get(&vc4_hdmi->pdev->dev));
+
+ if (vc4_hdmi->hpd_gpio) {
+@@ -218,11 +220,13 @@ vc4_hdmi_connector_detect(struct drm_con
+
+ vc4_hdmi_enable_scrambling(&vc4_hdmi->encoder.base.base);
+ pm_runtime_put(&vc4_hdmi->pdev->dev);
++ mutex_unlock(&vc4_hdmi->mutex);
+ return connector_status_connected;
+ }
+
+ cec_phys_addr_invalidate(vc4_hdmi->cec_adap);
+ pm_runtime_put(&vc4_hdmi->pdev->dev);
++ mutex_unlock(&vc4_hdmi->mutex);
+ return connector_status_disconnected;
+ }
+
+@@ -239,10 +243,14 @@ static int vc4_hdmi_connector_get_modes(
+ int ret = 0;
+ struct edid *edid;
+
++ mutex_lock(&vc4_hdmi->mutex);
++
+ edid = drm_get_edid(connector, vc4_hdmi->ddc);
+ cec_s_phys_addr_from_edid(vc4_hdmi->cec_adap, edid);
+- if (!edid)
+- return -ENODEV;
++ if (!edid) {
++ ret = -ENODEV;
++ goto out;
++ }
+
+ vc4_encoder->hdmi_monitor = drm_detect_hdmi_monitor(edid);
+
+@@ -262,6 +270,9 @@ static int vc4_hdmi_connector_get_modes(
+ }
+ }
+
++out:
++ mutex_unlock(&vc4_hdmi->mutex);
++
+ return ret;
+ }
+
+@@ -478,6 +489,8 @@ static void vc4_hdmi_set_avi_infoframe(s
+ union hdmi_infoframe frame;
+ int ret;
+
++ lockdep_assert_held(&vc4_hdmi->mutex);
++
+ ret = drm_hdmi_avi_infoframe_from_display_mode(&frame.avi,
+ connector, mode);
+ if (ret < 0) {
+@@ -529,6 +542,8 @@ static void vc4_hdmi_set_hdr_infoframe(s
+ struct drm_connector_state *conn_state = connector->state;
+ union hdmi_infoframe frame;
+
++ lockdep_assert_held(&vc4_hdmi->mutex);
++
+ if (!vc4_hdmi->variant->supports_hdr)
+ return;
+
+@@ -545,6 +560,8 @@ static void vc4_hdmi_set_infoframes(stru
+ {
+ struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
+
++ lockdep_assert_held(&vc4_hdmi->mutex);
++
+ vc4_hdmi_set_avi_infoframe(encoder);
+ vc4_hdmi_set_spd_infoframe(encoder);
+ /*
+@@ -564,6 +581,8 @@ static bool vc4_hdmi_supports_scrambling
+ struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
+ struct drm_display_info *display = &vc4_hdmi->connector.display_info;
+
++ lockdep_assert_held(&vc4_hdmi->mutex);
++
+ if (!vc4_encoder->hdmi_monitor)
+ return false;
+
+@@ -582,6 +601,8 @@ static void vc4_hdmi_enable_scrambling(s
+ struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
+ unsigned long flags;
+
++ lockdep_assert_held(&vc4_hdmi->mutex);
++
+ if (!vc4_hdmi_supports_scrambling(encoder, mode))
+ return;
+
+@@ -651,6 +672,8 @@ static void vc4_hdmi_encoder_post_crtc_d
+ struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
+ unsigned long flags;
+
++ mutex_lock(&vc4_hdmi->mutex);
++
+ spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
+
+ HDMI_WRITE(HDMI_RAM_PACKET_CONFIG, 0);
+@@ -667,6 +690,8 @@ static void vc4_hdmi_encoder_post_crtc_d
+ spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
+
+ vc4_hdmi_disable_scrambling(encoder);
++
++ mutex_unlock(&vc4_hdmi->mutex);
+ }
+
+ static void vc4_hdmi_encoder_post_crtc_powerdown(struct drm_encoder *encoder,
+@@ -676,6 +701,8 @@ static void vc4_hdmi_encoder_post_crtc_p
+ unsigned long flags;
+ int ret;
+
++ mutex_lock(&vc4_hdmi->mutex);
++
+ spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
+ HDMI_WRITE(HDMI_VID_CTL,
+ HDMI_READ(HDMI_VID_CTL) | VC4_HD_VID_CTL_BLANKPIX);
+@@ -690,6 +717,8 @@ static void vc4_hdmi_encoder_post_crtc_p
+ ret = pm_runtime_put(&vc4_hdmi->pdev->dev);
+ if (ret < 0)
+ DRM_ERROR("Failed to release power domain: %d\n", ret);
++
++ mutex_unlock(&vc4_hdmi->mutex);
+ }
+
+ static void vc4_hdmi_encoder_disable(struct drm_encoder *encoder)
+@@ -986,6 +1015,8 @@ static void vc4_hdmi_encoder_pre_crtc_co
+ unsigned long flags;
+ int ret;
+
++ mutex_lock(&vc4_hdmi->mutex);
++
+ /*
+ * As stated in RPi's vc4 firmware "HDMI state machine (HSM) clock must
+ * be faster than pixel clock, infinitesimally faster, tested in
+@@ -1006,13 +1037,13 @@ static void vc4_hdmi_encoder_pre_crtc_co
+ ret = clk_set_min_rate(vc4_hdmi->hsm_clock, hsm_rate);
+ if (ret) {
+ DRM_ERROR("Failed to set HSM clock rate: %d\n", ret);
+- return;
++ goto out;
+ }
+
+ ret = pm_runtime_resume_and_get(&vc4_hdmi->pdev->dev);
+ if (ret < 0) {
+ DRM_ERROR("Failed to retain power domain: %d\n", ret);
+- return;
++ goto out;
+ }
+
+ ret = clk_set_rate(vc4_hdmi->pixel_clock, pixel_rate);
+@@ -1064,13 +1095,16 @@ static void vc4_hdmi_encoder_pre_crtc_co
+ if (vc4_hdmi->variant->set_timings)
+ vc4_hdmi->variant->set_timings(vc4_hdmi, conn_state, mode);
+
++ mutex_unlock(&vc4_hdmi->mutex);
++
+ return;
+
+ err_disable_pixel_clock:
+ clk_disable_unprepare(vc4_hdmi->pixel_clock);
+ err_put_runtime_pm:
+ pm_runtime_put(&vc4_hdmi->pdev->dev);
+-
++out:
++ mutex_unlock(&vc4_hdmi->mutex);
+ return;
+ }
+
+@@ -1082,6 +1116,8 @@ static void vc4_hdmi_encoder_pre_crtc_en
+ struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
+ unsigned long flags;
+
++ mutex_lock(&vc4_hdmi->mutex);
++
+ if (vc4_encoder->hdmi_monitor &&
+ drm_default_rgb_quant_range(mode) == HDMI_QUANTIZATION_RANGE_LIMITED) {
+ if (vc4_hdmi->variant->csc_setup)
+@@ -1098,6 +1134,8 @@ static void vc4_hdmi_encoder_pre_crtc_en
+ spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
+ HDMI_WRITE(HDMI_FIFO_CTL, VC4_HDMI_FIFO_CTL_MASTER_SLAVE_N);
+ spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
++
++ mutex_unlock(&vc4_hdmi->mutex);
+ }
+
+ static void vc4_hdmi_encoder_post_crtc_enable(struct drm_encoder *encoder,
+@@ -1111,6 +1149,8 @@ static void vc4_hdmi_encoder_post_crtc_e
+ unsigned long flags;
+ int ret;
+
++ mutex_lock(&vc4_hdmi->mutex);
++
+ spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
+
+ HDMI_WRITE(HDMI_VID_CTL,
+@@ -1170,6 +1210,8 @@ static void vc4_hdmi_encoder_post_crtc_e
+
+ vc4_hdmi_recenter_fifo(vc4_hdmi);
+ vc4_hdmi_enable_scrambling(encoder);
++
++ mutex_unlock(&vc4_hdmi->mutex);
+ }
+
+ static void vc4_hdmi_encoder_enable(struct drm_encoder *encoder)
+@@ -1313,6 +1355,7 @@ static void vc4_hdmi_set_n_cts(struct vc
+ u32 n, cts;
+ u64 tmp;
+
++ lockdep_assert_held(&vc4_hdmi->mutex);
+ lockdep_assert_held(&vc4_hdmi->hw_lock);
+
+ n = 128 * samplerate / 1000;
+@@ -1346,13 +1389,17 @@ static int vc4_hdmi_audio_startup(struct
+ struct drm_encoder *encoder = &vc4_hdmi->encoder.base.base;
+ unsigned long flags;
+
++ mutex_lock(&vc4_hdmi->mutex);
++
+ /*
+ * If the HDMI encoder hasn't probed, or the encoder is
+ * currently in DVI mode, treat the codec dai as missing.
+ */
+ if (!encoder->crtc || !(HDMI_READ(HDMI_RAM_PACKET_CONFIG) &
+- VC4_HDMI_RAM_PACKET_ENABLE))
++ VC4_HDMI_RAM_PACKET_ENABLE)) {
++ mutex_unlock(&vc4_hdmi->mutex);
+ return -ENODEV;
++ }
+
+ vc4_hdmi->audio.streaming = true;
+
+@@ -1368,6 +1415,8 @@ static int vc4_hdmi_audio_startup(struct
+ if (vc4_hdmi->variant->phy_rng_enable)
+ vc4_hdmi->variant->phy_rng_enable(vc4_hdmi);
+
++ mutex_unlock(&vc4_hdmi->mutex);
++
+ return 0;
+ }
+
+@@ -1378,6 +1427,8 @@ static void vc4_hdmi_audio_reset(struct
+ unsigned long flags;
+ int ret;
+
++ lockdep_assert_held(&vc4_hdmi->mutex);
++
+ vc4_hdmi->audio.streaming = false;
+ ret = vc4_hdmi_stop_packet(encoder, HDMI_INFOFRAME_TYPE_AUDIO, false);
+ if (ret)
+@@ -1397,6 +1448,8 @@ static void vc4_hdmi_audio_shutdown(stru
+ struct vc4_hdmi *vc4_hdmi = dev_get_drvdata(dev);
+ unsigned long flags;
+
++ mutex_lock(&vc4_hdmi->mutex);
++
+ spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
+
+ HDMI_WRITE(HDMI_MAI_CTL,
+@@ -1411,6 +1464,8 @@ static void vc4_hdmi_audio_shutdown(stru
+
+ vc4_hdmi->audio.streaming = false;
+ vc4_hdmi_audio_reset(vc4_hdmi);
++
++ mutex_unlock(&vc4_hdmi->mutex);
+ }
+
+ static int sample_rate_to_mai_fmt(int samplerate)
+@@ -1469,6 +1524,8 @@ static int vc4_hdmi_audio_prepare(struct
+ dev_dbg(dev, "%s: %u Hz, %d bit, %d channels\n", __func__,
+ sample_rate, params->sample_width, channels);
+
++ mutex_lock(&vc4_hdmi->mutex);
++
+ vc4_hdmi_audio_set_mai_clock(vc4_hdmi, sample_rate);
+
+ spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
+@@ -1523,6 +1580,8 @@ static int vc4_hdmi_audio_prepare(struct
+ memcpy(&vc4_hdmi->audio.infoframe, &params->cea, sizeof(params->cea));
+ vc4_hdmi_set_audio_infoframe(encoder);
+
++ mutex_unlock(&vc4_hdmi->mutex);
++
+ return 0;
+ }
+
+@@ -1565,7 +1624,9 @@ static int vc4_hdmi_audio_get_eld(struct
+ struct vc4_hdmi *vc4_hdmi = dev_get_drvdata(dev);
+ struct drm_connector *connector = &vc4_hdmi->connector;
+
++ mutex_lock(&vc4_hdmi->mutex);
+ memcpy(buf, connector->eld, min(sizeof(connector->eld), len));
++ mutex_unlock(&vc4_hdmi->mutex);
+
+ return 0;
+ }
+@@ -1902,6 +1963,17 @@ static int vc4_hdmi_cec_enable(struct ce
+ u32 val;
+ int ret;
+
++ /*
++ * NOTE: This function should really take vc4_hdmi->mutex, but doing so
++ * results in a reentrancy since cec_s_phys_addr_from_edid() called in
++ * .detect or .get_modes might call .adap_enable, which leads to this
++ * function being called with that mutex held.
++ *
++ * Concurrency is not an issue for the moment since we don't share any
++ * state with KMS, so we can ignore the lock for now, but we need to
++ * keep it in mind if we were to change that assumption.
++ */
++
+ ret = pm_runtime_resume_and_get(&vc4_hdmi->pdev->dev);
+ if (ret)
+ return ret;
+@@ -1948,6 +2020,17 @@ static int vc4_hdmi_cec_disable(struct c
+ struct vc4_hdmi *vc4_hdmi = cec_get_drvdata(adap);
+ unsigned long flags;
+
++ /*
++ * NOTE: This function should really take vc4_hdmi->mutex, but doing so
++ * results in a reentrancy since cec_s_phys_addr_from_edid() called in
++ * .detect or .get_modes might call .adap_enable, which leads to this
++ * function being called with that mutex held.
++ *
++ * Concurrency is not an issue for the moment since we don't share any
++ * state with KMS, so we can ignore the lock for now, but we need to
++ * keep it in mind if we were to change that assumption.
++ */
++
+ spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
+
+ if (!vc4_hdmi->variant->external_irq_controller)
+@@ -1976,6 +2059,17 @@ static int vc4_hdmi_cec_adap_log_addr(st
+ struct vc4_hdmi *vc4_hdmi = cec_get_drvdata(adap);
+ unsigned long flags;
+
++ /*
++ * NOTE: This function should really take vc4_hdmi->mutex, but doing so
++ * results in a reentrancy since cec_s_phys_addr_from_edid() called in
++ * .detect or .get_modes might call .adap_enable, which leads to this
++ * function being called with that mutex held.
++ *
++ * Concurrency is not an issue for the moment since we don't share any
++ * state with KMS, so we can ignore the lock for now, but we need to
++ * keep it in mind if we were to change that assumption.
++ */
++
+ spin_lock_irqsave(&vc4_hdmi->hw_lock, flags);
+ HDMI_WRITE(HDMI_CEC_CNTRL_1,
+ (HDMI_READ(HDMI_CEC_CNTRL_1) & ~VC4_HDMI_CEC_ADDR_MASK) |
+@@ -1994,6 +2088,17 @@ static int vc4_hdmi_cec_adap_transmit(st
+ u32 val;
+ unsigned int i;
+
++ /*
++ * NOTE: This function should really take vc4_hdmi->mutex, but doing so
++ * results in a reentrancy since cec_s_phys_addr_from_edid() called in
++ * .detect or .get_modes might call .adap_enable, which leads to this
++ * function being called with that mutex held.
++ *
++ * Concurrency is not an issue for the moment since we don't share any
++ * state with KMS, so we can ignore the lock for now, but we need to
++ * keep it in mind if we were to change that assumption.
++ */
++
+ if (msg->len > 16) {
+ drm_err(dev, "Attempting to transmit too much data (%d)\n", msg->len);
+ return -ENOMEM;
+@@ -2349,6 +2454,7 @@ static int vc4_hdmi_bind(struct device *
+ vc4_hdmi = devm_kzalloc(dev, sizeof(*vc4_hdmi), GFP_KERNEL);
+ if (!vc4_hdmi)
+ return -ENOMEM;
++ mutex_init(&vc4_hdmi->mutex);
+ spin_lock_init(&vc4_hdmi->hw_lock);
+ INIT_DELAYED_WORK(&vc4_hdmi->scrambling_work, vc4_hdmi_scrambling_wq);
+
+--- a/drivers/gpu/drm/vc4/vc4_hdmi.h
++++ b/drivers/gpu/drm/vc4/vc4_hdmi.h
+@@ -184,6 +184,20 @@ struct vc4_hdmi {
+ * @hw_lock: Spinlock protecting device register access.
+ */
+ spinlock_t hw_lock;
++
++ /**
++ * @mutex: Mutex protecting the driver access across multiple
++ * frameworks (KMS, ALSA).
++ *
++ * NOTE: While supported, CEC has been left out since
++ * cec_s_phys_addr_from_edid() might call .adap_enable and lead to a
++ * reentrancy issue between .get_modes (or .detect) and .adap_enable.
++ * Since we don't share any state between the CEC hooks and KMS', it's
++ * not a big deal. The only trouble might come from updating the CEC
++ * clock divider which might be affected by a modeset, but CEC should
++ * be resilient to that.
++ */
++ struct mutex mutex;
+ };
+
+ static inline struct vc4_hdmi *
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-07 20:34:20 +0000