Commit d3dacc70 authored by Ramalingam C's avatar Ramalingam C Committed by Daniel Vetter
Browse files

drm/i915: wrapping all hdcp var into intel_hdcp 



Considering significant number of HDCP specific variables, it will
be clean to have separate struct for HDCP.

New structure called intel_hdcp is added within intel_connector.

v2:
  struct hdcp statically allocated. [Sean Paul]
  enable and disable function parameters are retained.[Sean Paul]
v3:
  No Changes.
v4:
  Commit msg is rephrased [Uma]
v5:
  Comment for mutex definition.
v6:
  hdcp_ prefix from all intel_hdcp members are removed [Sean Paul]
  inline function intel_hdcp_to_connector is defined [Sean Paul]
v7:
  %s/uint64_t/u64
v8:
  Rebased

Signed-off-by: default avatarRamalingam C <ramalingam.c@intel.com>
Reviewed-by: default avatarSean Paul <seanpaul@chromium.org>
Reviewed-by: default avatarUma Shankar <uma.shankar@intel.com>
Signed-off-by: default avatarDaniel Vetter <daniel.vetter@ffwll.ch>
Link: https://patchwork.freedesktop.org/patch/msgid/1540806351-7137-2-git-send-email-ramalingam.c@intel.com
parent 1e016a86

drivers/gpu/drm/i915/i915_debugfs.c

+1 −1
Original line number Diff line number Diff line
@@ -4986,7 +4986,7 @@ static int i915_hdcp_sink_capability_show(struct seq_file *m, void *data) 
		return -ENODEV;



	/* HDCP is supported by connector */

	if (!intel_connector->hdcp_shim)

	if (!intel_connector->hdcp.shim)

		return -EINVAL;



	seq_printf(m, "%s:%d HDCP version: ", connector->name,

drivers/gpu/drm/i915/intel_display.c

+3 −3
Original line number Diff line number Diff line
@@ -15769,9 +15769,9 @@ static void intel_hpd_poll_fini(struct drm_device *dev) 
	for_each_intel_connector_iter(connector, &conn_iter) {

		if (connector->modeset_retry_work.func)

			cancel_work_sync(&connector->modeset_retry_work);

		if (connector->hdcp_shim) {

			cancel_delayed_work_sync(&connector->hdcp_check_work);

			cancel_work_sync(&connector->hdcp_prop_work);

		if (connector->hdcp.shim) {

			cancel_delayed_work_sync(&connector->hdcp.check_work);

			cancel_work_sync(&connector->hdcp.prop_work);

		}

	}

	drm_connector_list_iter_end(&conn_iter);

drivers/gpu/drm/i915/intel_drv.h

+10 −5
Original line number Diff line number Diff line
@@ -381,6 +381,15 @@ struct intel_hdcp_shim { 
			    bool *hdcp_capable);

};



struct intel_hdcp {

	const struct intel_hdcp_shim *shim;

	/* Mutex for hdcp state of the connector */

	struct mutex mutex;

	u64 value;

	struct delayed_work check_work;

	struct work_struct prop_work;

};



struct intel_connector {

	struct drm_connector base;

	/*
@@ -413,11 +422,7 @@ struct intel_connector { 
	/* Work struct to schedule a uevent on link train failure */

	struct work_struct modeset_retry_work;



	const struct intel_hdcp_shim *hdcp_shim;

	struct mutex hdcp_mutex;

	uint64_t hdcp_value; /* protected by hdcp_mutex */

	struct delayed_work hdcp_check_work;

	struct work_struct hdcp_prop_work;

	struct intel_hdcp hdcp;

};



struct intel_digital_connector_state {

drivers/gpu/drm/i915/intel_hdcp.c

+60 −49
Original line number Diff line number Diff line
@@ -55,7 +55,7 @@ int intel_hdcp_read_valid_bksv(struct intel_digital_port *intel_dig_port, 
bool intel_hdcp_capable(struct intel_connector *connector)

{

	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);

	const struct intel_hdcp_shim *shim = connector->hdcp_shim;

	const struct intel_hdcp_shim *shim = connector->hdcp.shim;

	bool capable = false;

	u8 bksv[5];
@@ -655,6 +655,7 @@ static int intel_hdcp_auth(struct intel_digital_port *intel_dig_port, 


static int _intel_hdcp_disable(struct intel_connector *connector)

{

	struct intel_hdcp *hdcp = &connector->hdcp;

	struct drm_i915_private *dev_priv = connector->base.dev->dev_private;

	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);

	enum port port = intel_dig_port->base.port;
@@ -670,7 +671,7 @@ static int _intel_hdcp_disable(struct intel_connector *connector) 
		return -ETIMEDOUT;

	}



	ret = connector->hdcp_shim->toggle_signalling(intel_dig_port, false);

	ret = hdcp->shim->toggle_signalling(intel_dig_port, false);

	if (ret) {

		DRM_ERROR("Failed to disable HDCP signalling\n");

		return ret;
@@ -682,6 +683,7 @@ static int _intel_hdcp_disable(struct intel_connector *connector) 


static int _intel_hdcp_enable(struct intel_connector *connector)

{

	struct intel_hdcp *hdcp = &connector->hdcp;

	struct drm_i915_private *dev_priv = connector->base.dev->dev_private;

	int i, ret, tries = 3;
@@ -706,8 +708,7 @@ static int _intel_hdcp_enable(struct intel_connector *connector) 


	/* Incase of authentication failures, HDCP spec expects reauth. */

	for (i = 0; i < tries; i++) {

		ret = intel_hdcp_auth(conn_to_dig_port(connector),

				      connector->hdcp_shim);

		ret = intel_hdcp_auth(conn_to_dig_port(connector), hdcp->shim);

		if (!ret)

			return 0;
@@ -721,38 +722,46 @@ static int _intel_hdcp_enable(struct intel_connector *connector) 
	return ret;

}



static inline

struct intel_connector *intel_hdcp_to_connector(struct intel_hdcp *hdcp)

{

	return container_of(hdcp, struct intel_connector, hdcp);

}



static void intel_hdcp_check_work(struct work_struct *work)

{

	struct intel_connector *connector = container_of(to_delayed_work(work),

							 struct intel_connector,

							 hdcp_check_work);

	struct intel_hdcp *hdcp = container_of(to_delayed_work(work),

					       struct intel_hdcp,

					       check_work);

	struct intel_connector *connector = intel_hdcp_to_connector(hdcp);



	if (!intel_hdcp_check_link(connector))

		schedule_delayed_work(&connector->hdcp_check_work,

		schedule_delayed_work(&hdcp->check_work,

				      DRM_HDCP_CHECK_PERIOD_MS);

}



static void intel_hdcp_prop_work(struct work_struct *work)

{

	struct intel_connector *connector = container_of(work,

							 struct intel_connector,

							 hdcp_prop_work);

	struct intel_hdcp *hdcp = container_of(work, struct intel_hdcp,

					       prop_work);

	struct intel_connector *connector = intel_hdcp_to_connector(hdcp);

	struct drm_device *dev = connector->base.dev;

	struct drm_connector_state *state;



	drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);

	mutex_lock(&connector->hdcp_mutex);

	mutex_lock(&hdcp->mutex);



	/*

	 * This worker is only used to flip between ENABLED/DESIRED. Either of

	 * those to UNDESIRED is handled by core. If hdcp_value == UNDESIRED,

	 * those to UNDESIRED is handled by core. If value == UNDESIRED,

	 * we're running just after hdcp has been disabled, so just exit

	 */

	if (connector->hdcp_value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {

	if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {

		state = connector->base.state;

		state->content_protection = connector->hdcp_value;

		state->content_protection = hdcp->value;

	}



	mutex_unlock(&connector->hdcp_mutex);

	mutex_unlock(&hdcp->mutex);

	drm_modeset_unlock(&dev->mode_config.connection_mutex);

}
@@ -764,8 +773,9 @@ bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port) 
}



int intel_hdcp_init(struct intel_connector *connector,

		    const struct intel_hdcp_shim *hdcp_shim)

		    const struct intel_hdcp_shim *shim)

{

	struct intel_hdcp *hdcp = &connector->hdcp;

	int ret;



	ret = drm_connector_attach_content_protection_property(
@@ -773,51 +783,53 @@ int intel_hdcp_init(struct intel_connector *connector, 
	if (ret)

		return ret;



	connector->hdcp_shim = hdcp_shim;

	mutex_init(&connector->hdcp_mutex);

	INIT_DELAYED_WORK(&connector->hdcp_check_work, intel_hdcp_check_work);

	INIT_WORK(&connector->hdcp_prop_work, intel_hdcp_prop_work);

	hdcp->shim = shim;

	mutex_init(&hdcp->mutex);

	INIT_DELAYED_WORK(&hdcp->check_work, intel_hdcp_check_work);

	INIT_WORK(&hdcp->prop_work, intel_hdcp_prop_work);

	return 0;

}



int intel_hdcp_enable(struct intel_connector *connector)

{

	struct intel_hdcp *hdcp = &connector->hdcp;

	int ret;



	if (!connector->hdcp_shim)

	if (!hdcp->shim)

		return -ENOENT;



	mutex_lock(&connector->hdcp_mutex);

	mutex_lock(&hdcp->mutex);



	ret = _intel_hdcp_enable(connector);

	if (ret)

		goto out;



	connector->hdcp_value = DRM_MODE_CONTENT_PROTECTION_ENABLED;

	schedule_work(&connector->hdcp_prop_work);

	schedule_delayed_work(&connector->hdcp_check_work,

	hdcp->value = DRM_MODE_CONTENT_PROTECTION_ENABLED;

	schedule_work(&hdcp->prop_work);

	schedule_delayed_work(&hdcp->check_work,

			      DRM_HDCP_CHECK_PERIOD_MS);

out:

	mutex_unlock(&connector->hdcp_mutex);

	mutex_unlock(&hdcp->mutex);

	return ret;

}



int intel_hdcp_disable(struct intel_connector *connector)

{

	struct intel_hdcp *hdcp = &connector->hdcp;

	int ret = 0;



	if (!connector->hdcp_shim)

	if (!hdcp->shim)

		return -ENOENT;



	mutex_lock(&connector->hdcp_mutex);

	mutex_lock(&hdcp->mutex);



	if (connector->hdcp_value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {

		connector->hdcp_value = DRM_MODE_CONTENT_PROTECTION_UNDESIRED;

	if (hdcp->value != DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {

		hdcp->value = DRM_MODE_CONTENT_PROTECTION_UNDESIRED;

		ret = _intel_hdcp_disable(connector);

	}



	mutex_unlock(&connector->hdcp_mutex);

	cancel_delayed_work_sync(&connector->hdcp_check_work);

	mutex_unlock(&hdcp->mutex);

	cancel_delayed_work_sync(&hdcp->check_work);

	return ret;

}
@@ -857,17 +869,18 @@ void intel_hdcp_atomic_check(struct drm_connector *connector, 
/* Implements Part 3 of the HDCP authorization procedure */

int intel_hdcp_check_link(struct intel_connector *connector)

{

	struct intel_hdcp *hdcp = &connector->hdcp;

	struct drm_i915_private *dev_priv = connector->base.dev->dev_private;

	struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);

	enum port port = intel_dig_port->base.port;

	int ret = 0;



	if (!connector->hdcp_shim)

	if (!hdcp->shim)

		return -ENOENT;



	mutex_lock(&connector->hdcp_mutex);

	mutex_lock(&hdcp->mutex);



	if (connector->hdcp_value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)

	if (hdcp->value == DRM_MODE_CONTENT_PROTECTION_UNDESIRED)

		goto out;



	if (!(I915_READ(PORT_HDCP_STATUS(port)) & HDCP_STATUS_ENC)) {
@@ -875,17 +888,15 @@ int intel_hdcp_check_link(struct intel_connector *connector) 
			  connector->base.name, connector->base.base.id,

			  I915_READ(PORT_HDCP_STATUS(port)));

		ret = -ENXIO;

		connector->hdcp_value = DRM_MODE_CONTENT_PROTECTION_DESIRED;

		schedule_work(&connector->hdcp_prop_work);

		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;

		schedule_work(&hdcp->prop_work);

		goto out;

	}



	if (connector->hdcp_shim->check_link(intel_dig_port)) {

		if (connector->hdcp_value !=

		    DRM_MODE_CONTENT_PROTECTION_UNDESIRED) {

			connector->hdcp_value =

				DRM_MODE_CONTENT_PROTECTION_ENABLED;

			schedule_work(&connector->hdcp_prop_work);

	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);

		}

		goto out;

	}
@@ -896,20 +907,20 @@ 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);

		connector->hdcp_value = DRM_MODE_CONTENT_PROTECTION_DESIRED;

		schedule_work(&connector->hdcp_prop_work);

		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;

		schedule_work(&hdcp->prop_work);

		goto out;

	}



	ret = _intel_hdcp_enable(connector);

	if (ret) {

		DRM_ERROR("Failed to enable hdcp (%d)\n", ret);

		connector->hdcp_value = DRM_MODE_CONTENT_PROTECTION_DESIRED;

		schedule_work(&connector->hdcp_prop_work);

		hdcp->value = DRM_MODE_CONTENT_PROTECTION_DESIRED;

		schedule_work(&hdcp->prop_work);

		goto out;

	}



out:

	mutex_unlock(&connector->hdcp_mutex);

	mutex_unlock(&hdcp->mutex);

	return ret;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE