drm/i915: Reinitialize sink scrambling/TMDS clock ratio on HPD

The LG 4k TV I have doesn't deassert HPD when I turn the TV off, but
when I turn it back on it will pulse the HPD line. By that time it has
forgotten everything we told it about scrambling and the clock ratio.
Hence if we want to get a picture out if it again we have to tell it
whether we're currently sending scrambled data or not. Implement
that via the encoder->hotplug() hook.

v2: Force a full modeset to not follow the HDMI 2.0 spec more
    closely (Shashank)

[pushed with whitespace fixes to make sparse happy]
Cc: Shashank Sharma <shashank.sharma@intel.com>
Cc: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Lyude Paul <lyude@redhat.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20180117192149.17760-1-ville.syrjala@linux.intel.com

diff --git a/drivers/gpu/drm/i915/intel_crt.c b/drivers/gpu/drm/i915/intel_crt.c
index 391dd69ae0a491ef980f90c6070beb98532539ae..c0a8805b277faaa19d2bc0215fd8e9217e0ec297 100644 (file)
--- a/drivers/gpu/drm/i915/intel_crt.c
+++ b/drivers/gpu/drm/i915/intel_crt.c
@@ -956,8 +956,10 @@ void intel_crt_init(struct drm_i915_private *dev_priv)
        crt->base.power_domain = POWER_DOMAIN_PORT_CRT;
 
        if (I915_HAS_HOTPLUG(dev_priv) &&
-           !dmi_check_system(intel_spurious_crt_detect))
+           !dmi_check_system(intel_spurious_crt_detect)) {
                crt->base.hpd_pin = HPD_CRT;
+               crt->base.hotplug = intel_encoder_hotplug;
+       }
 
        if (HAS_DDI(dev_priv)) {
                crt->base.port = PORT_E;

diff --git a/drivers/gpu/drm/i915/intel_ddi.c b/drivers/gpu/drm/i915/intel_ddi.c
index bfdaa5d86861761b48af378a85e198366c92c1cb..e5b5d21c3c09f1b5834508850d4c24925757aa03 100644 (file)
--- a/drivers/gpu/drm/i915/intel_ddi.c
+++ b/drivers/gpu/drm/i915/intel_ddi.c
@@ -25,6 +25,7 @@
  *
  */
 
+#include <drm/drm_scdc_helper.h>
 #include "i915_drv.h"
 #include "intel_drv.h"
 
@@ -2798,6 +2799,147 @@ intel_ddi_init_dp_connector(struct intel_digital_port *intel_dig_port)
        return connector;
 }
 
+static int modeset_pipe(struct drm_crtc *crtc,
+                       struct drm_modeset_acquire_ctx *ctx)
+{
+       struct drm_atomic_state *state;
+       struct drm_crtc_state *crtc_state;
+       int ret;
+
+       state = drm_atomic_state_alloc(crtc->dev);
+       if (!state)
+               return -ENOMEM;
+
+       state->acquire_ctx = ctx;
+
+       crtc_state = drm_atomic_get_crtc_state(state, crtc);
+       if (IS_ERR(crtc_state)) {
+               ret = PTR_ERR(crtc_state);
+               goto out;
+       }
+
+       crtc_state->mode_changed = true;
+
+       ret = drm_atomic_add_affected_connectors(state, crtc);
+       if (ret)
+               goto out;
+
+       ret = drm_atomic_add_affected_planes(state, crtc);
+       if (ret)
+               goto out;
+
+       ret = drm_atomic_commit(state);
+       if (ret)
+               goto out;
+
+       return 0;
+
+ out:
+       drm_atomic_state_put(state);
+
+       return ret;
+}
+
+static int intel_hdmi_reset_link(struct intel_encoder *encoder,
+                                struct drm_modeset_acquire_ctx *ctx)
+{
+       struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
+       struct intel_hdmi *hdmi = enc_to_intel_hdmi(&encoder->base);
+       struct intel_connector *connector = hdmi->attached_connector;
+       struct i2c_adapter *adapter =
+               intel_gmbus_get_adapter(dev_priv, hdmi->ddc_bus);
+       struct drm_connector_state *conn_state;
+       struct intel_crtc_state *crtc_state;
+       struct intel_crtc *crtc;
+       u8 config;
+       int ret;
+
+       if (!connector || connector->base.status != connector_status_connected)
+               return 0;
+
+       ret = drm_modeset_lock(&dev_priv->drm.mode_config.connection_mutex,
+                              ctx);
+       if (ret)
+               return ret;
+
+       conn_state = connector->base.state;
+
+       crtc = to_intel_crtc(conn_state->crtc);
+       if (!crtc)
+               return 0;
+
+       ret = drm_modeset_lock(&crtc->base.mutex, ctx);
+       if (ret)
+               return ret;
+
+       crtc_state = to_intel_crtc_state(crtc->base.state);
+
+       WARN_ON(!intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI));
+
+       if (!crtc_state->base.active)
+               return 0;
+
+       if (!crtc_state->hdmi_high_tmds_clock_ratio &&
+           !crtc_state->hdmi_scrambling)
+               return 0;
+
+       if (conn_state->commit &&
+           !try_wait_for_completion(&conn_state->commit->hw_done))
+               return 0;
+
+       ret = drm_scdc_readb(adapter, SCDC_TMDS_CONFIG, &config);
+       if (ret < 0) {
+               DRM_ERROR("Failed to read TMDS config: %d\n", ret);
+               return 0;
+       }
+
+       if (!!(config & SCDC_TMDS_BIT_CLOCK_RATIO_BY_40) ==
+           crtc_state->hdmi_high_tmds_clock_ratio &&
+           !!(config & SCDC_SCRAMBLING_ENABLE) ==
+           crtc_state->hdmi_scrambling)
+               return 0;
+
+       /*
+        * HDMI 2.0 says that one should not send scrambled data
+        * prior to configuring the sink scrambling, and that
+        * TMDS clock/data transmission should be suspended when
+        * changing the TMDS clock rate in the sink. So let's
+        * just do a full modeset here, even though some sinks
+        * would be perfectly happy if were to just reconfigure
+        * the SCDC settings on the fly.
+        */
+       return modeset_pipe(&crtc->base, ctx);
+}
+
+static bool intel_ddi_hotplug(struct intel_encoder *encoder,
+                             struct intel_connector *connector)
+{
+       struct drm_modeset_acquire_ctx ctx;
+       bool changed;
+       int ret;
+
+       changed = intel_encoder_hotplug(encoder, connector);
+
+       drm_modeset_acquire_init(&ctx, 0);
+
+       for (;;) {
+               ret = intel_hdmi_reset_link(encoder, &ctx);
+
+               if (ret == -EDEADLK) {
+                       drm_modeset_backoff(&ctx);
+                       continue;
+               }
+
+               break;
+       }
+
+       drm_modeset_drop_locks(&ctx);
+       drm_modeset_acquire_fini(&ctx);
+       WARN(ret, "Acquiring modeset locks failed with %i\n", ret);
+
+       return changed;
+}
+
 static struct intel_connector *
 intel_ddi_init_hdmi_connector(struct intel_digital_port *intel_dig_port)
 {
@@ -2914,6 +3056,10 @@ void intel_ddi_init(struct drm_i915_private *dev_priv, enum port port)
        drm_encoder_init(&dev_priv->drm, encoder, &intel_ddi_funcs,
                         DRM_MODE_ENCODER_TMDS, "DDI %c", port_name(port));
 
+       if (init_hdmi)
+               intel_encoder->hotplug = intel_ddi_hotplug;
+       else
+               intel_encoder->hotplug = intel_encoder_hotplug;
        intel_encoder->compute_output_type = intel_ddi_compute_output_type;
        intel_encoder->compute_config = intel_ddi_compute_config;
        intel_encoder->enable = intel_enable_ddi;

diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c
index c722a6750e90a9b14f2c75060702856467a4cd80..7cc1720a437d99fbfb88f4d7b7606c5d59cc5778 100644 (file)
--- a/drivers/gpu/drm/i915/intel_dp.c
+++ b/drivers/gpu/drm/i915/intel_dp.c
@@ -6393,6 +6393,7 @@ bool intel_dp_init(struct drm_i915_private *dev_priv,
                             "DP %c", port_name(port)))
                goto err_encoder_init;
 
+       intel_encoder->hotplug = intel_encoder_hotplug;
        intel_encoder->compute_config = intel_dp_compute_config;
        intel_encoder->get_hw_state = intel_dp_get_hw_state;
        intel_encoder->get_config = intel_dp_get_config;

diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h
index 652b11e788ccd79b8bb3039f66021e56e10d8034..2ae6d5548171750a54956a32ded4d2fc77d0bf65 100644 (file)
--- a/drivers/gpu/drm/i915/intel_drv.h
+++ b/drivers/gpu/drm/i915/intel_drv.h
@@ -215,7 +215,8 @@ struct intel_encoder {
        enum intel_output_type type;
        enum port port;
        unsigned int cloneable;
-       void (*hot_plug)(struct intel_encoder *);
+       bool (*hotplug)(struct intel_encoder *encoder,
+                       struct intel_connector *connector);
        enum intel_output_type (*compute_output_type)(struct intel_encoder *,
                                                      struct intel_crtc_state *,
                                                      struct drm_connector_state *);
@@ -1704,7 +1705,8 @@ int intel_dsi_dcs_init_backlight_funcs(struct intel_connector *intel_connector);
 void intel_dvo_init(struct drm_i915_private *dev_priv);
 /* intel_hotplug.c */
 void intel_hpd_poll_init(struct drm_i915_private *dev_priv);
-
+bool intel_encoder_hotplug(struct intel_encoder *encoder,
+                          struct intel_connector *connector);
 
 /* legacy fbdev emulation in intel_fbdev.c */
 #ifdef CONFIG_DRM_FBDEV_EMULATION

diff --git a/drivers/gpu/drm/i915/intel_hdmi.c b/drivers/gpu/drm/i915/intel_hdmi.c
index f5d7bfb4300622088a00a41fd05972d93c0a5853..1baef4ac7ecb1fd8664e4e056108fb47305abc3d 100644 (file)
--- a/drivers/gpu/drm/i915/intel_hdmi.c
+++ b/drivers/gpu/drm/i915/intel_hdmi.c
@@ -2383,6 +2383,7 @@ void intel_hdmi_init(struct drm_i915_private *dev_priv,
                         &intel_hdmi_enc_funcs, DRM_MODE_ENCODER_TMDS,
                         "HDMI %c", port_name(port));
 
+       intel_encoder->hotplug = intel_encoder_hotplug;
        intel_encoder->compute_config = intel_hdmi_compute_config;
        if (HAS_PCH_SPLIT(dev_priv)) {
                intel_encoder->disable = pch_disable_hdmi;

diff --git a/drivers/gpu/drm/i915/intel_hotplug.c b/drivers/gpu/drm/i915/intel_hotplug.c
index fe28c1ea84a5d3ebb6a70b0ce798706b0b059769..0e3d3e89d66a142e92a194f0affb1ddde1c63e31 100644 (file)
--- a/drivers/gpu/drm/i915/intel_hotplug.c
+++ b/drivers/gpu/drm/i915/intel_hotplug.c
@@ -274,24 +274,26 @@ static void intel_hpd_irq_storm_reenable_work(struct work_struct *work)
        intel_runtime_pm_put(dev_priv);
 }
 
-static bool intel_hpd_irq_event(struct drm_device *dev,
-                               struct drm_connector *connector)
+bool intel_encoder_hotplug(struct intel_encoder *encoder,
+                          struct intel_connector *connector)
 {
+       struct drm_device *dev = connector->base.dev;
        enum drm_connector_status old_status;
 
        WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
-       old_status = connector->status;
+       old_status = connector->base.status;
 
-       connector->status = drm_helper_probe_detect(connector, NULL, false);
+       connector->base.status =
+               drm_helper_probe_detect(&connector->base, NULL, false);
 
-       if (old_status == connector->status)
+       if (old_status == connector->base.status)
                return false;
 
        DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %s to %s\n",
-                     connector->base.id,
-                     connector->name,
+                     connector->base.base.id,
+                     connector->base.name,
                      drm_get_connector_status_name(old_status),
-                     drm_get_connector_status_name(connector->status));
+                     drm_get_connector_status_name(connector->base.status));
 
        return true;
 }
@@ -381,10 +383,9 @@ static void i915_hotplug_work_func(struct work_struct *work)
                if (hpd_event_bits & (1 << intel_encoder->hpd_pin)) {
                        DRM_DEBUG_KMS("Connector %s (pin %i) received hotplug event.\n",
                                      connector->name, intel_encoder->hpd_pin);
-                       if (intel_encoder->hot_plug)
-                               intel_encoder->hot_plug(intel_encoder);
-                       if (intel_hpd_irq_event(dev, connector))
-                               changed = true;
+
+                       changed |= intel_encoder->hotplug(intel_encoder,
+                                                         intel_connector);
                }
        }
        drm_connector_list_iter_end(&conn_iter);