drm/vc4: hdmi: Introduce a scdc_enabled flag

We currently rely on two functions, vc4_hdmi_supports_scrambling() and
vc4_hdmi_mode_needs_scrambling() to determine if we should enable and
disable the scrambler for any given mode.

Since we might need to disable the controller at boot, we also always
run vc4_hdmi_disable_scrambling() and thus call those functions without
a mode yet, which in turns need to make some special casing in order for
it to work.

Instead of duplicating the check for whether or not we need to take care
of the scrambler in both vc4_hdmi_enable_scrambling() and
vc4_hdmi_disable_scrambling(), we can do that check only when we enable
it and store whether or not it's been enabled in our private structure.

We also need to initialize that flag at true to make sure we disable the
scrambler at boot since we can't really know its state yet.

This allows to simplify a bit that part of the driver, and removes one
user of our copy of the CRTC adjusted mode outside of KMS (since
vc4_hdmi_disable_scrambling() might be called from the hotplug interrupt
handler).

It also removes our last user of the legacy encoder->crtc pointer.

Link: https://lore.kernel.org/r/20211025141113.702757-10-maxime@cerno.tech
Acked-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Signed-off-by: Maxime Ripard <maxime@cerno.tech>

diff --git a/drivers/gpu/drm/vc4/vc4_hdmi.c b/drivers/gpu/drm/vc4/vc4_hdmi.c
index 34ac8ad..fab9b93 100644 (file)
--- a/drivers/gpu/drm/vc4/vc4_hdmi.c
+++ b/drivers/gpu/drm/vc4/vc4_hdmi.c
@@ -616,6 +616,8 @@ static void vc4_hdmi_enable_scrambling(struct drm_encoder *encoder)
                   VC5_HDMI_SCRAMBLER_CTL_ENABLE);
        spin_unlock_irqrestore(&vc4_hdmi->hw_lock, flags);
 
+       vc4_hdmi->scdc_enabled = true;
+
        queue_delayed_work(system_wq, &vc4_hdmi->scrambling_work,
                           msecs_to_jiffies(SCRAMBLING_POLLING_DELAY_MS));
 }
@@ -623,22 +625,14 @@ static void vc4_hdmi_enable_scrambling(struct drm_encoder *encoder)
 static void vc4_hdmi_disable_scrambling(struct drm_encoder *encoder)
 {
        struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
-       struct drm_display_mode *mode = &vc4_hdmi->saved_adjusted_mode;
-       struct drm_crtc *crtc = encoder->crtc;
        unsigned long flags;
 
        lockdep_assert_held(&vc4_hdmi->mutex);
 
-       /*
-        * At boot, encoder->crtc will be NULL. Since we don't know the
-        * state of the scrambler and in order to avoid any
-        * inconsistency, let's disable it all the time.
-        */
-       if (crtc && !vc4_hdmi_supports_scrambling(encoder, mode))
+       if (!vc4_hdmi->scdc_enabled)
                return;
 
-       if (crtc && !vc4_hdmi_mode_needs_scrambling(mode))
-               return;
+       vc4_hdmi->scdc_enabled = false;
 
        if (delayed_work_pending(&vc4_hdmi->scrambling_work))
                cancel_delayed_work_sync(&vc4_hdmi->scrambling_work);
@@ -2512,6 +2506,14 @@ static int vc4_hdmi_bind(struct device *dev, struct device *master, void *data)
        vc4_hdmi->pdev = pdev;
        vc4_hdmi->variant = variant;
 
+       /*
+        * Since we don't know the state of the controller and its
+        * display (if any), let's assume it's always enabled.
+        * vc4_hdmi_disable_scrambling() will thus run at boot, make
+        * sure it's disabled, and avoid any inconsistency.
+        */
+       vc4_hdmi->scdc_enabled = true;
+
        ret = variant->init_resources(vc4_hdmi);
        if (ret)
                return ret;

diff --git a/drivers/gpu/drm/vc4/vc4_hdmi.h b/drivers/gpu/drm/vc4/vc4_hdmi.h
index 5d3e977..36c0b08 100644 (file)
--- a/drivers/gpu/drm/vc4/vc4_hdmi.h
+++ b/drivers/gpu/drm/vc4/vc4_hdmi.h
@@ -209,6 +209,12 @@ struct vc4_hdmi {
         * Protected by @mutex.
         */
        bool output_enabled;
+
+       /**
+        * @scdc_enabled: Is the HDMI controller currently running with
+        * the scrambler on? Protected by @mutex.
+        */
+       bool scdc_enabled;
 };
 
 static inline struct vc4_hdmi *