From: Sean Paul <seanp...@chromium.org>

This is a bit of housecleaning for a future patch. Instead of sprinkling
hdcp->value assignments and prop_work scheduling everywhere, introduce a
function to do it for us.

Reviewed-by: Ramalingam C <ramalinga...@intel.com>
Signed-off-by: Sean Paul <seanp...@chromium.org>
Link: 
https://patchwork.freedesktop.org/patch/msgid/20191203173638.94919-7-s...@poorly.run
 #v1
Link: 
https://patchwork.freedesktop.org/patch/msgid/20191212190230.188505-7-s...@poorly.run
 #v2

Changes in v2:
-None
Changes in v3:
-None
---
 drivers/gpu/drm/i915/display/intel_hdcp.c | 67 ++++++++++++++++-------
 1 file changed, 46 insertions(+), 21 deletions(-)

diff --git a/drivers/gpu/drm/i915/display/intel_hdcp.c 
b/drivers/gpu/drm/i915/display/intel_hdcp.c
index f8d56d3b2ddb..798e7e1a19fc 100644
--- a/drivers/gpu/drm/i915/display/intel_hdcp.c
+++ b/drivers/gpu/drm/i915/display/intel_hdcp.c
@@ -852,6 +852,21 @@ struct intel_connector *intel_hdcp_to_connector(struct 
intel_hdcp *hdcp)
        return container_of(hdcp, struct intel_connector, hdcp);
 }
 
+static void intel_hdcp_update_value(struct intel_connector *connector,
+                                   u64 value, bool update_property)
+{
+       struct intel_hdcp *hdcp = &connector->hdcp;
+
+       WARN_ON(!mutex_is_locked(&hdcp->mutex));
+
+       if (hdcp->value == value)
+               return;
+
+       hdcp->value = value;
+       if (update_property)
+               schedule_work(&hdcp->prop_work);
+}
+
 /* Implements Part 3 of the HDCP authorization procedure */
 static int intel_hdcp_check_link(struct intel_connector *connector)
 {
@@ -878,15 +893,16 @@ static int intel_hdcp_check_link(struct intel_connector 
*connector)
                          I915_READ(HDCP_STATUS(dev_priv, cpu_transcoder,
                                                port)));
                ret = -ENXIO;
-               hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-               schedule_work(&hdcp->prop_work);
+               intel_hdcp_update_value(connector,
+                                       DRM_MODE_CONTENT_PROTECTION_DESIRED,
+                                       true);
                goto out;
        }
 
        if (hdcp->shim->check_link(intel_dig_port)) {
                if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
-                       hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
-                       schedule_work(&hdcp->prop_work);
+                       intel_hdcp_update_value(connector,
+                               DRM_MODE_CONTENT_PROTECTION_ENABLED, true);
                }
                goto out;
        }
@@ -897,16 +913,18 @@ static int intel_hdcp_check_link(struct intel_connector 
*connector)
        ret = _intel_hdcp_disable(connector);
        if (ret) {
                DRM_ERROR("Failed to disable hdcp (%d)\n", ret);
-               hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-               schedule_work(&hdcp->prop_work);
+               intel_hdcp_update_value(connector,
+                                       DRM_MODE_CONTENT_PROTECTION_DESIRED,
+                                       true);
                goto out;
        }
 
        ret = _intel_hdcp_enable(connector);
        if (ret) {
                DRM_ERROR("Failed to enable hdcp (%d)\n", ret);
-               hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-               schedule_work(&hdcp->prop_work);
+               intel_hdcp_update_value(connector,
+                                       DRM_MODE_CONTENT_PROTECTION_DESIRED,
+                                       true);
                goto out;
        }
 
@@ -1716,16 +1734,18 @@ static int intel_hdcp2_check_link(struct 
intel_connector *connector)
                          I915_READ(HDCP2_STATUS(dev_priv, cpu_transcoder,
                                                 port)));
                ret = -ENXIO;
-               hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-               schedule_work(&hdcp->prop_work);
+               intel_hdcp_update_value(connector,
+                                       DRM_MODE_CONTENT_PROTECTION_DESIRED,
+                                       true);
                goto out;
        }
 
        ret = hdcp->shim->check_2_2_link(intel_dig_port);
        if (ret == HDCP_LINK_PROTECTED) {
                if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
-                       hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
-                       schedule_work(&hdcp->prop_work);
+                       intel_hdcp_update_value(connector,
+                                       DRM_MODE_CONTENT_PROTECTION_ENABLED,
+                                       true);
                }
                goto out;
        }
@@ -1737,8 +1757,9 @@ static int intel_hdcp2_check_link(struct intel_connector 
*connector)
                DRM_DEBUG_KMS("HDCP2.2 Downstream topology change\n");
                ret = hdcp2_authenticate_repeater_topology(connector);
                if (!ret) {
-                       hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
-                       schedule_work(&hdcp->prop_work);
+                       intel_hdcp_update_value(connector,
+                                       DRM_MODE_CONTENT_PROTECTION_ENABLED,
+                                       true);
                        goto out;
                }
                DRM_DEBUG_KMS("[%s:%d] Repeater topology auth failed.(%d)\n",
@@ -1753,8 +1774,8 @@ static int intel_hdcp2_check_link(struct intel_connector 
*connector)
        if (ret) {
                DRM_ERROR("[%s:%d] Failed to disable hdcp2.2 (%d)\n",
                          connector->base.name, connector->base.base.id, ret);
-               hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-               schedule_work(&hdcp->prop_work);
+               intel_hdcp_update_value(connector,
+                               DRM_MODE_CONTENT_PROTECTION_DESIRED, true);
                goto out;
        }
 
@@ -1763,8 +1784,9 @@ static int intel_hdcp2_check_link(struct intel_connector 
*connector)
                DRM_DEBUG_KMS("[%s:%d] Failed to enable hdcp2.2 (%d)\n",
                              connector->base.name, connector->base.base.id,
                              ret);
-               hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;
-               schedule_work(&hdcp->prop_work);
+               intel_hdcp_update_value(connector,
+                                       DRM_MODE_CONTENT_PROTECTION_DESIRED,
+                                       true);
                goto out;
        }
 
@@ -2004,8 +2026,9 @@ int intel_hdcp_enable(struct intel_connector *connector,
 
        if (!ret) {
                schedule_delayed_work(&hdcp->check_work, check_link_interval);
-               hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;
-               schedule_work(&hdcp->prop_work);
+               intel_hdcp_update_value(connector,
+                                       DRM_MODE_CONTENT_PROTECTION_ENABLED,
+                                       true);
        }
 
        mutex_unlock(&hdcp->mutex);
@@ -2023,7 +2046,9 @@ int intel_hdcp_disable(struct intel_connector *connector)
        mutex_lock(&hdcp->mutex);
 
        if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {
-               hdcp->value = DRM_MODE_CONTENT_PROTECTION_UNDESIRED;
+               intel_hdcp_update_value(connector,
+                                       DRM_MODE_CONTENT_PROTECTION_UNDESIRED,
+                                       false);
                if (hdcp->hdcp2_encrypted)
                        ret = _intel_hdcp2_disable(connector);
                else if (hdcp->hdcp_encrypted)
-- 
Sean Paul, Software Engineer, Google / Chromium OS

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Reply via email to