bcm27xx: add support for linux v5.15

Build system: x86_64
Build-tested: bcm2708, bcm2709, bcm2710, bcm2711
Run-tested: bcm2708/RPiB+, bcm2709/RPi3B, bcm2710/RPi3B, bcm2711/RPi4B

Signed-off-by: Marty Jones <mj8263788@gmail.com>
Signed-off-by: Álvaro Fernández Rojas <noltari@gmail.com>

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 *