On Wed, Feb 12, 2020 at 03:59:38PM +0530, Ramalingam C wrote:

As we are not using the sysfs infrastructure anymore, link to it is removed. And global srm data and mutex to protect it are removed, with required handling at revocation check function.

v2: srm_data is dropped and few more comments are addressed. v3: ptr passing around is fixed with functional testing. v4: fix htmldoc [lkp]

Signed-off-by: Ramalingam C ramalingam.c@intel.com

I think we could probably improve things even further, but this is a good start. Thanks for doing this!

Reviewed-by: Sean Paul sean@poorly.run

Suggested-by: Sean Paul seanpaul@chromium.org

drivers/gpu/drm/drm_hdcp.c | 158 ++++++++++++--------------------- drivers/gpu/drm/drm_internal.h | 4 - drivers/gpu/drm/drm_sysfs.c | 2 - include/drm/drm_hdcp.h | 4 +- 4 files changed, 61 insertions(+), 107 deletions(-)

diff --git a/drivers/gpu/drm/drm_hdcp.c b/drivers/gpu/drm/drm_hdcp.c index 9191633a3c43..7f386adcf872 100644 --- a/drivers/gpu/drm/drm_hdcp.c +++ b/drivers/gpu/drm/drm_hdcp.c @@ -23,14 +23,6 @@

#include "drm_internal.h"

-static struct hdcp_srm {

• u32 revoked_ksv_cnt;
• u8 *revoked_ksv_list;
• /* Mutex to protect above struct member */
• struct mutex mutex;

-} *srm_data;

static inline void drm_hdcp_print_ksv(const u8 *ksv) { DRM_DEBUG("\t%#02x, %#02x, %#02x, %#02x, %#02x\n", @@ -60,11 +52,11 @@ static u32 drm_hdcp_get_revoked_ksv_count(const u8 *buf, u32 vrls_length) return ksv_count; }

-static u32 drm_hdcp_get_revoked_ksvs(const u8 *buf, u8 *revoked_ksv_list, +static u32 drm_hdcp_get_revoked_ksvs(const u8 *buf, u8 **revoked_ksv_list, u32 vrls_length) {

• u32 parsed_bytes = 0, ksv_count = 0; u32 vrl_ksv_cnt, vrl_ksv_sz, vrl_idx = 0;

• u32 parsed_bytes = 0, ksv_count = 0;

  do { vrl_ksv_cnt = *buf;

@@ -74,10 +66,10 @@ static u32 drm_hdcp_get_revoked_ksvs(const u8 *buf, u8 *revoked_ksv_list,

DRM_DEBUG("vrl: %d, Revoked KSVs: %d\n", vrl_idx++,
	  vrl_ksv_cnt);

• memcpy(revoked_ksv_list, buf, vrl_ksv_sz);
  

• memcpy((*revoked_ksv_list) + (ksv_count * DRM_HDCP_KSV_LEN),
  

•        buf, vrl_ksv_sz);
  
  

  ksv_count += vrl_ksv_cnt;

• revoked_ksv_list += vrl_ksv_sz;
  

  buf += vrl_ksv_sz;

  parsed_bytes += (vrl_ksv_sz + 1);

@@ -91,7 +83,8 @@ static inline u32 get_vrl_length(const u8 *buf) return drm_hdcp_be24_to_cpu(buf); }

-static int drm_hdcp_parse_hdcp1_srm(const u8 *buf, size_t count) +static int drm_hdcp_parse_hdcp1_srm(const u8 *buf, size_t count,

• 		    u8 **revoked_ksv_list, u32 *revoked_ksv_cnt)
  

{ struct hdcp_srm_header *header; u32 vrl_length, ksv_count; @@ -131,29 +124,28 @@ static int drm_hdcp_parse_hdcp1_srm(const u8 *buf, size_t count) ksv_count = drm_hdcp_get_revoked_ksv_count(buf, vrl_length); if (!ksv_count) { DRM_DEBUG("Revoked KSV count is 0\n");

• return count;
  

• return 0;
  

  }

• kfree(srm_data->revoked_ksv_list);
• srm_data->revoked_ksv_list = kcalloc(ksv_count, DRM_HDCP_KSV_LEN,

• 			     GFP_KERNEL);
  

• if (!srm_data->revoked_ksv_list) {

• *revoked_ksv_list = kcalloc(ksv_count, DRM_HDCP_KSV_LEN, GFP_KERNEL);
• if (!*revoked_ksv_list) { DRM_ERROR("Out of Memory\n"); return -ENOMEM; }

• if (drm_hdcp_get_revoked_ksvs(buf, srm_data->revoked_ksv_list,

• if (drm_hdcp_get_revoked_ksvs(buf, revoked_ksv_list, vrl_length) != ksv_count) {

• srm_data->revoked_ksv_cnt = 0;
  

• kfree(srm_data->revoked_ksv_list);
  

• *revoked_ksv_cnt = 0;
  

• kfree(*revoked_ksv_list);
  

  return -EINVAL; }

• srm_data->revoked_ksv_cnt = ksv_count;
• return count;

• *revoked_ksv_cnt = ksv_count;
• return 0;

}

-static int drm_hdcp_parse_hdcp2_srm(const u8 *buf, size_t count) +static int drm_hdcp_parse_hdcp2_srm(const u8 *buf, size_t count,

• 		    u8 **revoked_ksv_list, u32 *revoked_ksv_cnt)
  

{ struct hdcp_srm_header *header; u32 vrl_length, ksv_count, ksv_sz; @@ -195,13 +187,11 @@ static int drm_hdcp_parse_hdcp2_srm(const u8 *buf, size_t count) ksv_count = (*buf << 2) | DRM_HDCP_2_KSV_COUNT_2_LSBITS(*(buf + 1)); if (!ksv_count) { DRM_DEBUG("Revoked KSV count is 0\n");

• return count;
  

• return 0;
  

  }

• kfree(srm_data->revoked_ksv_list);
• srm_data->revoked_ksv_list = kcalloc(ksv_count, DRM_HDCP_KSV_LEN,

• 			     GFP_KERNEL);
  

• if (!srm_data->revoked_ksv_list) {

• *revoked_ksv_list = kcalloc(ksv_count, DRM_HDCP_KSV_LEN, GFP_KERNEL);
• if (!*revoked_ksv_list) { DRM_ERROR("Out of Memory\n"); return -ENOMEM; }

@@ -210,10 +200,10 @@ static int drm_hdcp_parse_hdcp2_srm(const u8 *buf, size_t count) buf += DRM_HDCP_2_NO_OF_DEV_PLUS_RESERVED_SZ;

DRM_DEBUG("Revoked KSVs: %d\n", ksv_count);

• memcpy(srm_data->revoked_ksv_list, buf, ksv_sz);

• memcpy(*revoked_ksv_list, buf, ksv_sz);

• srm_data->revoked_ksv_cnt = ksv_count;
• return count;

• *revoked_ksv_cnt = ksv_count;
• return 0;

}

static inline bool is_srm_version_hdcp1(const u8 *buf) @@ -226,22 +216,27 @@ static inline bool is_srm_version_hdcp2(const u8 *buf) return *buf == (u8)(DRM_HDCP_2_SRM_ID << 4 | DRM_HDCP_2_INDICATOR); }

-static void drm_hdcp_srm_update(const u8 *buf, size_t count) +static int drm_hdcp_srm_update(const u8 *buf, size_t count,

• 	       u8 **revoked_ksv_list, u32 *revoked_ksv_cnt)
  

{ if (count < sizeof(struct hdcp_srm_header))

• return;
  

• return -EINVAL;
  
  

  if (is_srm_version_hdcp1(buf))

• drm_hdcp_parse_hdcp1_srm(buf, count);
  

• return drm_hdcp_parse_hdcp1_srm(buf, count, revoked_ksv_list,
  

• 				revoked_ksv_cnt);
  

  else if (is_srm_version_hdcp2(buf))

• drm_hdcp_parse_hdcp2_srm(buf, count);
  

• return drm_hdcp_parse_hdcp2_srm(buf, count, revoked_ksv_list,
  

• 				revoked_ksv_cnt);
  

• else

• return -EINVAL;
  

}

-static void drm_hdcp_request_srm(struct drm_device *drm_dev) +static int drm_hdcp_request_srm(struct drm_device *drm_dev,

• 		u8 **revoked_ksv_list, u32 *revoked_ksv_cnt)
  

{ char fw_name[36] = "display_hdcp_srm.bin"; const struct firmware *fw;

• int ret;

  ret = request_firmware_direct(&fw, (const char *)fw_name,

@@ -250,10 +245,12 @@ static void drm_hdcp_request_srm(struct drm_device *drm_dev) goto exit;

if (fw->size && fw->data)

• drm_hdcp_srm_update(fw->data, fw->size);
  

• ret = drm_hdcp_srm_update(fw->data, fw->size, revoked_ksv_list,
  

• 			  revoked_ksv_cnt);
  
  

exit: release_firmware(fw);

• return ret;

}

/** @@ -279,71 +276,34 @@ static void drm_hdcp_request_srm(struct drm_device *drm_dev)

• https://www.digital-cp.com/sites/default/files/specifications/HDCP%20on%20HD...
• Returns:

• • TRUE on any of the KSV is revoked, else FALSE.

• • Count of the revoked KSVs or -ve error number incase of the failure.
  */

-bool drm_hdcp_check_ksvs_revoked(struct drm_device *drm_dev, u8 *ksvs,

• 		 u32 ksv_count)
  

+int drm_hdcp_check_ksvs_revoked(struct drm_device *drm_dev, u8 *ksvs,

• 		u32 ksv_count)
  

{

• u32 rev_ksv_cnt, cnt, i, j;
• u8 *rev_ksv_list;
• if (!srm_data)

• return false;
  

• mutex_lock(&srm_data->mutex);
• drm_hdcp_request_srm(drm_dev);
• rev_ksv_cnt = srm_data->revoked_ksv_cnt;
• rev_ksv_list = srm_data->revoked_ksv_list;
• /* If the Revoked ksv list is empty */
• if (!rev_ksv_cnt || !rev_ksv_list) {

• mutex_unlock(&srm_data->mutex);
  

• return false;
  

• }
• for (cnt = 0; cnt < ksv_count; cnt++) {

• rev_ksv_list = srm_data->revoked_ksv_list;
  

• for (i = 0; i < rev_ksv_cnt; i++) {
  

• 	for (j = 0; j < DRM_HDCP_KSV_LEN; j++)
  

• 		if (ksvs[j] != rev_ksv_list[j]) {
  

• 			break;
  

• 		} else if (j == (DRM_HDCP_KSV_LEN - 1)) {
  

• 			DRM_DEBUG("Revoked KSV is ");
  

• 			drm_hdcp_print_ksv(ksvs);
  

• 			mutex_unlock(&srm_data->mutex);
  

• 			return true;
  

• 		}
  

• 	/* Move the offset to next KSV in the revoked list */
  

• 	rev_ksv_list += DRM_HDCP_KSV_LEN;
  

• }
  

• /* Iterate to next ksv_offset */
  

• ksvs += DRM_HDCP_KSV_LEN;
  

• }
• mutex_unlock(&srm_data->mutex);
• return false;

• u32 revoked_ksv_cnt = 0, i, j;
• u8 *revoked_ksv_list = NULL;
• int ret = 0;
• ret = drm_hdcp_request_srm(drm_dev, &revoked_ksv_list,

• 		   &revoked_ksv_cnt);
  

• /* revoked_ksv_cnt will be zero when above function failed */
• for (i = 0; i < revoked_ksv_cnt; i++)

• for  (j = 0; j < ksv_count; j++)
  

• 	if (!memcmp(&ksvs[j * DRM_HDCP_KSV_LEN],
  

• 		    &revoked_ksv_list[i * DRM_HDCP_KSV_LEN],
  

• 		    DRM_HDCP_KSV_LEN)) {
  

• 		DRM_DEBUG("Revoked KSV is ");
  

• 		drm_hdcp_print_ksv(&ksvs[j * DRM_HDCP_KSV_LEN]);
  

• 		ret++;
  

• 	}
  

• kfree(revoked_ksv_list);
• return ret;

} EXPORT_SYMBOL_GPL(drm_hdcp_check_ksvs_revoked);

-int drm_setup_hdcp_srm(struct class *drm_class) -{

• srm_data = kzalloc(sizeof(*srm_data), GFP_KERNEL);
• if (!srm_data)

• return -ENOMEM;
  

• mutex_init(&srm_data->mutex);
• return 0;

-}

-void drm_teardown_hdcp_srm(struct class *drm_class) -{

• if (srm_data) {

• kfree(srm_data->revoked_ksv_list);
  

• kfree(srm_data);
  

• }

-}

static struct drm_prop_enum_list drm_cp_enum_list[] = { { DRM_MODE_CONTENT_PROTECTION_UNDESIRED, "Undesired" }, { DRM_MODE_CONTENT_PROTECTION_DESIRED, "Desired" }, diff --git a/drivers/gpu/drm/drm_internal.h b/drivers/gpu/drm/drm_internal.h index aeec2e68d772..5714a78365ac 100644 --- a/drivers/gpu/drm/drm_internal.h +++ b/drivers/gpu/drm/drm_internal.h @@ -236,7 +236,3 @@ int drm_syncobj_query_ioctl(struct drm_device *dev, void *data, void drm_framebuffer_print_info(struct drm_printer *p, unsigned int indent, const struct drm_framebuffer *fb); int drm_framebuffer_debugfs_init(struct drm_minor *minor);

-/* drm_hdcp.c */ -int drm_setup_hdcp_srm(struct class *drm_class); -void drm_teardown_hdcp_srm(struct class *drm_class); diff --git a/drivers/gpu/drm/drm_sysfs.c b/drivers/gpu/drm/drm_sysfs.c index dd2bc85f43cc..2e83c3d72af9 100644 --- a/drivers/gpu/drm/drm_sysfs.c +++ b/drivers/gpu/drm/drm_sysfs.c @@ -85,7 +85,6 @@ int drm_sysfs_init(void) }

drm_class->devnode = drm_devnode;

• drm_setup_hdcp_srm(drm_class); return 0;

}

@@ -98,7 +97,6 @@ void drm_sysfs_destroy(void) { if (IS_ERR_OR_NULL(drm_class)) return;

• drm_teardown_hdcp_srm(drm_class); class_remove_file(drm_class, &class_attr_version.attr); class_destroy(drm_class); drm_class = NULL;

diff --git a/include/drm/drm_hdcp.h b/include/drm/drm_hdcp.h index 06a11202a097..d512089b873f 100644 --- a/include/drm/drm_hdcp.h +++ b/include/drm/drm_hdcp.h @@ -288,8 +288,8 @@ struct hdcp_srm_header { struct drm_device; struct drm_connector;

-bool drm_hdcp_check_ksvs_revoked(struct drm_device *dev,

• 		 u8 *ksvs, u32 ksv_count);
  

+int drm_hdcp_check_ksvs_revoked(struct drm_device *dev,

• 		u8 *ksvs, u32 ksv_count);
  

int drm_connector_attach_content_protection_property( struct drm_connector *connector, bool hdcp_content_type); void drm_hdcp_update_content_protection(struct drm_connector *connector, -- 2.20.1

---

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

On 2020-02-12 at 15:59:39 +0530, Ramalingam C wrote:

Need to extract the 2 most significant bits from a byte for constructing the revoked KSV count of the SRM.

Signed-off-by: Ramalingam C ramalingam.c@intel.com

include/drm/drm_hdcp.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/drm/drm_hdcp.h b/include/drm/drm_hdcp.h index d512089b873f..c6bab4986a65 100644 --- a/include/drm/drm_hdcp.h +++ b/include/drm/drm_hdcp.h @@ -276,7 +276,7 @@ void drm_hdcp_cpu_to_be24(u8 seq_num[HDCP_2_2_SEQ_NUM_LEN], u32 val) #define DRM_HDCP_2_VRL_LENGTH_SIZE 3 #define DRM_HDCP_2_DCP_SIG_SIZE 384 #define DRM_HDCP_2_NO_OF_DEV_PLUS_RESERVED_SZ 4 -#define DRM_HDCP_2_KSV_COUNT_2_LSBITS(byte) (((byte) & 0xC) >> 6) +#define DRM_HDCP_2_KSV_COUNT_2_LSBITS(byte) (((byte) & 0xC0) >> 6)

LGTM, verified wrt Table 5.1 HDCP HDMI specs page 64. Reviewed-by: Anshuman Gupta anshuman.gupta@intel.com

struct hdcp_srm_header { u8 srm_id; -- 2.20.1

---

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

On 2020-02-12 at 15:59:40 +0530, Ramalingam C wrote:

As per the HDCP2.2 compliance test 1B-10 expectation, when stream management for a repeater fails, we retry thrice and when it fails in all retries, HDCP2.2 reauthentication aborted at kernel.

v2: seq_num_m++ is extended for steam management failures too.[Anshuman] v3: use drm_dbg_kms instead of DRM_DEBUG_KMS [Anshuman] v4: dev_priv is used as i915 [JaniN]

Signed-off-by: Ramalingam C ramalingam.c@intel.com

drivers/gpu/drm/i915/display/intel_hdcp.c | 75 ++++++++++++++--------- 1 file changed, 46 insertions(+), 29 deletions(-)

diff --git a/drivers/gpu/drm/i915/display/intel_hdcp.c b/drivers/gpu/drm/i915/display/intel_hdcp.c index 30e0a3aa9d57..b24d12efae0a 100644 --- a/drivers/gpu/drm/i915/display/intel_hdcp.c +++ b/drivers/gpu/drm/i915/display/intel_hdcp.c @@ -1380,7 +1380,7 @@ static int hdcp2_session_key_exchange(struct intel_connector *connector) }

static -int hdcp2_propagate_stream_management_info(struct intel_connector *connector) +int _hdcp2_propagate_stream_management_info(struct intel_connector *connector) { struct intel_digital_port *intel_dig_port = intel_attached_dig_port(connector); struct intel_hdcp *hdcp = &connector->hdcp; @@ -1406,28 +1406,25 @@ int hdcp2_propagate_stream_management_info(struct intel_connector *connector) ret = shim->write_2_2_msg(intel_dig_port, &msgs.stream_manage, sizeof(msgs.stream_manage)); if (ret < 0)

• return ret;
  

• goto err_exit;
  
  

  ret = shim->read_2_2_msg(intel_dig_port, HDCP_2_2_REP_STREAM_READY, &msgs.stream_ready, sizeof(msgs.stream_ready)); if (ret < 0)

• return ret;
  

• goto err_exit;
  
  

  hdcp->port_data.seq_num_m = hdcp->seq_num_m; hdcp->port_data.streams[0].stream_type = hdcp->content_type;

• ret = hdcp2_verify_mprime(connector, &msgs.stream_ready);
• if (ret < 0)

• return ret;
  
  

+err_exit: hdcp->seq_num_m++;

• if (hdcp->seq_num_m > HDCP_2_2_SEQ_NUM_MAX) { DRM_DEBUG_KMS("seq_num_m roll over.\n");

• return -1;
  

• ret = -1;
  

  }

• return 0;

• return ret;

}

static @@ -1492,17 +1489,6 @@ int hdcp2_authenticate_repeater_topology(struct intel_connector *connector) return 0; }

-static int hdcp2_authenticate_repeater(struct intel_connector *connector) -{

• int ret;
• ret = hdcp2_authenticate_repeater_topology(connector);
• if (ret < 0)

• return ret;
  

• return hdcp2_propagate_stream_management_info(connector);

-}

static int hdcp2_authenticate_sink(struct intel_connector *connector) { struct intel_digital_port *intel_dig_port = intel_attached_dig_port(connector); @@ -1537,18 +1523,13 @@ static int hdcp2_authenticate_sink(struct intel_connector *connector) }

if (hdcp->is_repeater) {

• ret = hdcp2_authenticate_repeater(connector);
  

• ret = hdcp2_authenticate_repeater_topology(connector);
  

  if (ret < 0) { DRM_DEBUG_KMS("Repeater Auth Failed. Err: %d\n", ret); return ret; } }

• hdcp->port_data.streams[0].stream_type = hdcp->content_type;
• ret = hdcp2_authenticate_port(connector);
• if (ret < 0)

• return ret;
  

• return ret;

}

@@ -1626,14 +1607,50 @@ static int hdcp2_disable_encryption(struct intel_connector *connector) return ret; }

+static int +hdcp2_propagate_stream_management_info(struct intel_connector *connector) +{

• struct drm_i915_private *i915 = to_i915(connector->base.dev);
• int i, tries = 3, ret;
• if (!connector->hdcp.is_repeater)

• return 0;
  

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

• ret = _hdcp2_propagate_stream_management_info(connector);
  

• if (!ret)
  

• 	break;
  

• drm_dbg_kms(&i915->drm,
  

• 	    "HDCP2 stream management %d of %d Failed.(%d)\n",
  

• 	    i + 1, tries, ret);
  

• }
• return ret;

+}

static int hdcp2_authenticate_and_encrypt(struct intel_connector *connector) {

• struct drm_i915_private *i915 = to_i915(connector->base.dev);

• struct intel_hdcp *hdcp = &connector->hdcp; int ret, i, tries = 3;

  for (i = 0; i < tries; i++) { ret = hdcp2_authenticate_sink(connector);

• if (!ret)
  

• 	break;
  

• if (!ret) {
  

• 	ret = hdcp2_propagate_stream_management_info(connector);
  

IMHO hdcp2_propagate_stream_management_info should be called only for repeater rather then early return in funciton itself (theoretically it may avoid a stack operation). but this is also ok. Tested this patch on HDCP compliance. Tested-by: Anshuman Gupta anshuman.gupta@intel.com Reviewed-by: Anshuman Gupta anshuman.gupta@intel.com Thanks, Anshuman Gupta.

• 	if (!ret) {
  

• 		hdcp->port_data.streams[0].stream_type =
  

• 					hdcp->content_type;
  

• 		ret = hdcp2_authenticate_port(connector);
  

• 		if (!ret)
  

• 			break;
  

• 	} else {
  

• 		drm_dbg_kms(&i915->drm,
  

• 			    "HDCP2 stream management failed\n");
  

• 		break;
  

• 	}
  

• }
  
  

  /* Clearing the mei hdcp session */ DRM_DEBUG_KMS("HDCP2.2 Auth %d of %d Failed.(%d)\n",

@@ -1642,7 +1659,7 @@ static int hdcp2_authenticate_and_encrypt(struct intel_connector *connector) DRM_DEBUG_KMS("Port deauth failed.\n"); }

• if (i != tries) {

• if (!ret) { /*
  • Ensuring the required 200mSec min time interval between
  • Session Key Exchange and encryption.

-- 2.20.1

---

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

On Wed, Feb 12, 2020 at 03:59:41PM +0530, Ramalingam C wrote:

When roll over detected for seq_num_m, we shouldn't continue with stream management with rolled over value.

So we are terminating the stream management retry, on roll over of the seq_num_m.

v2: using drm_dbg_kms instead of DRM_DEBUG_KMS [Anshuman] v3: dev_priv is used as i915 [JaniN]

Signed-off-by: Ramalingam C ramalingam.c@intel.com

drivers/gpu/drm/i915/display/intel_hdcp.c | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/drivers/gpu/drm/i915/display/intel_hdcp.c b/drivers/gpu/drm/i915/display/intel_hdcp.c index b24d12efae0a..b35f50d4a0e9 100644 --- a/drivers/gpu/drm/i915/display/intel_hdcp.c +++ b/drivers/gpu/drm/i915/display/intel_hdcp.c @@ -1419,11 +1419,6 @@ int _hdcp2_propagate_stream_management_info(struct intel_connector *connector)

err_exit: hdcp->seq_num_m++;

• if (hdcp->seq_num_m > HDCP_2_2_SEQ_NUM_MAX) {

• DRM_DEBUG_KMS("seq_num_m roll over.\n");
  

• ret = -1;
  

• }
• return ret;

}

@@ -1618,8 +1613,11 @@ hdcp2_propagate_stream_management_info(struct intel_connector *connector)

for (i = 0; i < tries; i++) { ret = _hdcp2_propagate_stream_management_info(connector);

• if (!ret)
  

• if (!ret || connector->hdcp.seq_num_m > HDCP_2_2_SEQ_NUM_MAX) {
  

• 	if (connector->hdcp.seq_num_m > HDCP_2_2_SEQ_NUM_MAX)
  

• 		drm_dbg_kms(&i915->drm, "seq_num_m roll over.\n");
  break;
  

• }
  

IMO it doesn't read quite right bunching up a success outcome and a failure, and it's actually less code (character-wise) to do:

if (connector->hdcp.seq_num_m > HDCP_2_2_SEQ_NUM_MAX) { drm_dbg_kms(&i915->drm, "seq_num_m roll over.\n"); break; } else if (!ret) { break; }

feel free to add

Reviewed-by: Sean Paul sean@poorly.run

with this addressed

drm_dbg_kms(&i915->drm,
	    "HDCP2 stream management %d of %d Failed.(%d)\n",

-- 2.20.1

---

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

On Wed, 12 Feb 2020, Ramalingam C ramalingam.c@intel.com wrote:

Converts remaining instances of the printk based logging macros in i915/display/intel_hdcp.c with the struct drm_device based macros manually.

This is continuation of commit 65833c463886 ("drm/i915/hdcp: conversion to struct drm_device based logging macros.")

v2: i915_dev_priv is used instead of drm_device for reusability [JaniN]

There's still one dev_priv added, but no big deal.

Reviewed-by: Jani Nikula jani.nikula@intel.com

Signed-off-by: Ramalingam C ramalingam.c@intel.com cc: Jani Nikula jani.nikula@linux.intel.com

---

drivers/gpu/drm/i915/display/intel_hdcp.c | 108 ++++++++++++---------- 1 file changed, 61 insertions(+), 47 deletions(-)

diff --git a/drivers/gpu/drm/i915/display/intel_hdcp.c b/drivers/gpu/drm/i915/display/intel_hdcp.c index b35f50d4a0e9..c9841c82e213 100644 --- a/drivers/gpu/drm/i915/display/intel_hdcp.c +++ b/drivers/gpu/drm/i915/display/intel_hdcp.c @@ -43,6 +43,7 @@ static int intel_hdcp_read_valid_bksv(struct intel_digital_port *intel_dig_port, const struct intel_hdcp_shim *shim, u8 *bksv) {

• struct drm_i915_private *i915 = to_i915(intel_dig_port->base.base.dev); int ret, i, tries = 2;

  /* HDCP spec states that we must retry the bksv if it is invalid */

@@ -54,7 +55,7 @@ int intel_hdcp_read_valid_bksv(struct intel_digital_port *intel_dig_port, break; } if (i == tries) {

• DRM_DEBUG_KMS("Bksv is invalid\n");
  

• drm_dbg_kms(&i915->drm, "Bksv is invalid\n");
  

  return -ENODEV; }

@@ -485,8 +486,8 @@ int intel_hdcp_validate_v_prime(struct intel_connector *connector, return ret; sha_idx += sizeof(sha_text); } else {

• DRM_DEBUG_KMS("Invalid number of leftovers %d\n",
  

• 	      sha_leftovers);
  

• drm_dbg_kms(&dev_priv->drm, "Invalid number of leftovers %d\n",
  

• 	    sha_leftovers);
  

  return -EINVAL; }

@@ -514,11 +515,11 @@ int intel_hdcp_validate_v_prime(struct intel_connector *connector, rep_ctl | HDCP_SHA1_COMPLETE_HASH); if (intel_de_wait_for_set(dev_priv, HDCP_REP_CTL, HDCP_SHA1_COMPLETE, 1)) {

• DRM_ERROR("Timed out waiting for SHA1 complete\n");
  

• drm_err(&dev_priv->drm, "Timed out waiting for SHA1 complete\n");
  

  return -ETIMEDOUT; } if (!(intel_de_read(dev_priv, HDCP_REP_CTL) & HDCP_SHA1_V_MATCH)) {

• DRM_DEBUG_KMS("SHA-1 mismatch, HDCP failed\n");
  

• drm_dbg_kms(&dev_priv->drm, "SHA-1 mismatch, HDCP failed\n");
  

  return -ENXIO; }

@@ -537,7 +538,8 @@ int intel_hdcp_auth_downstream(struct intel_connector *connector)

ret = intel_hdcp_poll_ksv_fifo(intel_dig_port, shim); if (ret) {

• DRM_DEBUG_KMS("KSV list failed to become ready (%d)\n", ret);
  

• drm_dbg_kms(&dev_priv->drm,
  

• 	    "KSV list failed to become ready (%d)\n", ret);
  

  return ret; }

@@ -547,7 +549,7 @@ int intel_hdcp_auth_downstream(struct intel_connector *connector)

if (DRM_HDCP_MAX_DEVICE_EXCEEDED(bstatus[0]) || DRM_HDCP_MAX_CASCADE_EXCEEDED(bstatus[1])) {

• DRM_DEBUG_KMS("Max Topology Limit Exceeded\n");
  

• drm_dbg_kms(&dev_priv->drm, "Max Topology Limit Exceeded\n");
  

  return -EPERM; }

@@ -560,13 +562,14 @@ int intel_hdcp_auth_downstream(struct intel_connector *connector) */ num_downstream = DRM_HDCP_NUM_DOWNSTREAM(bstatus[0]); if (num_downstream == 0) {

• DRM_DEBUG_KMS("Repeater with zero downstream devices\n");
  

• drm_dbg_kms(&dev_priv->drm,
  

• 	    "Repeater with zero downstream devices\n");
  

  return -EINVAL; }

  ksv_fifo = kcalloc(DRM_HDCP_KSV_LEN, num_downstream, GFP_KERNEL); if (!ksv_fifo) {

• DRM_DEBUG_KMS("Out of mem: ksv_fifo\n");
  

• drm_dbg_kms(&dev_priv->drm, "Out of mem: ksv_fifo\n");
  

  return -ENOMEM; }

@@ -576,7 +579,7 @@ int intel_hdcp_auth_downstream(struct intel_connector *connector)

if (drm_hdcp_check_ksvs_revoked(&dev_priv->drm, ksv_fifo, num_downstream)) {

• DRM_ERROR("Revoked Ksv(s) in ksv_fifo\n");
  

• drm_err(&dev_priv->drm, "Revoked Ksv(s) in ksv_fifo\n");
  

  ret = -EPERM; goto err; }

@@ -594,12 +597,13 @@ int intel_hdcp_auth_downstream(struct intel_connector *connector) }

if (i == tries) {

• DRM_DEBUG_KMS("V Prime validation failed.(%d)\n", ret);
  

• drm_dbg_kms(&dev_priv->drm,
  

• 	    "V Prime validation failed.(%d)\n", ret);
  

  goto err; }

• DRM_DEBUG_KMS("HDCP is enabled (%d downstream devices)\n",

•       num_downstream);
  

• drm_dbg_kms(&dev_priv->drm, "HDCP is enabled (%d downstream devices)\n",

•     num_downstream);
  

  ret = 0;

err: kfree(ksv_fifo); @@ -642,7 +646,8 @@ static int intel_hdcp_auth(struct intel_connector *connector) if (ret) return ret; if (!hdcp_capable) {

• 	DRM_DEBUG_KMS("Panel is not HDCP capable\n");
  

• 	drm_dbg_kms(&dev_priv->drm,
  

• 		    "Panel is not HDCP capable\n");
  return -EINVAL;
  

  } }

@@ -659,7 +664,7 @@ static int intel_hdcp_auth(struct intel_connector *connector) if (intel_de_wait_for_set(dev_priv, HDCP_STATUS(dev_priv, cpu_transcoder, port), HDCP_STATUS_AN_READY, 1)) {

• DRM_ERROR("Timed out waiting for An\n");
  

• drm_err(&dev_priv->drm, "Timed out waiting for An\n");
  

  return -ETIMEDOUT; }

@@ -680,7 +685,7 @@ static int intel_hdcp_auth(struct intel_connector *connector) return ret;

if (drm_hdcp_check_ksvs_revoked(&dev_priv->drm, bksv.shim, 1)) {

• DRM_ERROR("BKSV is revoked\n");
  

• drm_err(&dev_priv->drm, "BKSV is revoked\n");
  

  return -EPERM; }

@@ -706,7 +711,7 @@ static int intel_hdcp_auth(struct intel_connector *connector) /* Wait for R0 ready */ if (wait_for(intel_de_read(dev_priv, HDCP_STATUS(dev_priv, cpu_transcoder, port)) & (HDCP_STATUS_R0_READY | HDCP_STATUS_ENC), 1)) {

• DRM_ERROR("Timed out waiting for R0 ready\n");
  

• drm_err(&dev_priv->drm, "Timed out waiting for R0 ready\n");
  

  return -ETIMEDOUT; }

@@ -743,8 +748,10 @@ static int intel_hdcp_auth(struct intel_connector *connector) }

if (i == tries) {

• DRM_DEBUG_KMS("Timed out waiting for Ri prime match (%x)\n",
  

• 	      intel_de_read(dev_priv, HDCP_STATUS(dev_priv, cpu_transcoder, port)));
  

• drm_dbg_kms(&dev_priv->drm,
  

• 	    "Timed out waiting for Ri prime match (%x)\n",
  

• 	    intel_de_read(dev_priv, HDCP_STATUS(dev_priv,
  

• 			  cpu_transcoder, port)));
  

  return -ETIMEDOUT; }

@@ -753,7 +760,7 @@ static int intel_hdcp_auth(struct intel_connector *connector) HDCP_STATUS(dev_priv, cpu_transcoder, port), HDCP_STATUS_ENC, ENCRYPT_STATUS_CHANGE_TIMEOUT_MS)) {

• DRM_ERROR("Timed out waiting for encryption\n");
  

• drm_err(&dev_priv->drm, "Timed out waiting for encryption\n");
  

  return -ETIMEDOUT; }

@@ -765,7 +772,7 @@ static int intel_hdcp_auth(struct intel_connector *connector) if (repeater_present) return intel_hdcp_auth_downstream(connector);

• DRM_DEBUG_KMS("HDCP is enabled (no repeater present)\n");

• drm_dbg_kms(&dev_priv->drm, "HDCP is enabled (no repeater present)\n"); return 0;

}

@@ -1270,7 +1277,7 @@ static int hdcp2_authentication_key_exchange(struct intel_connector *connector) return ret;

if (msgs.send_cert.rx_caps[0] != HDCP_2_2_RX_CAPS_VERSION_VAL) {

• DRM_DEBUG_KMS("cert.rx_caps dont claim HDCP2.2\n");
  

• drm_dbg_kms(&dev_priv->drm, "cert.rx_caps dont claim HDCP2.2\n");
  

  return -EINVAL; }

@@ -1279,7 +1286,7 @@ static int hdcp2_authentication_key_exchange(struct intel_connector *connector) if (drm_hdcp_check_ksvs_revoked(&dev_priv->drm, msgs.send_cert.cert_rx.receiver_id, 1)) {

• DRM_ERROR("Receiver ID is revoked\n");
  

• drm_err(&dev_priv->drm, "Receiver ID is revoked\n");
  

  return -EPERM; }

@@ -1446,7 +1453,7 @@ int hdcp2_authenticate_repeater_topology(struct intel_connector *connector)

if (HDCP_2_2_MAX_CASCADE_EXCEEDED(rx_info[1]) || HDCP_2_2_MAX_DEVS_EXCEEDED(rx_info[1])) {

• DRM_DEBUG_KMS("Topology Max Size Exceeded\n");
  

• drm_dbg_kms(&dev_priv->drm, "Topology Max Size Exceeded\n");
  

  return -EINVAL; }

@@ -1456,7 +1463,7 @@ int hdcp2_authenticate_repeater_topology(struct intel_connector *connector)

if (seq_num_v < hdcp->seq_num_v) { /* Roll over of the seq_num_v from repeater. Reauthenticate. */

• DRM_DEBUG_KMS("Seq_num_v roll over.\n");
  

• drm_dbg_kms(&dev_priv->drm, "Seq_num_v roll over.\n");
  

  return -EINVAL; }

@@ -1465,7 +1472,7 @@ int hdcp2_authenticate_repeater_topology(struct intel_connector *connector) if (drm_hdcp_check_ksvs_revoked(&dev_priv->drm, msgs.recvid_list.receiver_ids, device_cnt)) {

• DRM_ERROR("Revoked receiver ID(s) is in list\n");
  

• drm_err(&dev_priv->drm, "Revoked receiver ID(s) is in list\n");
  

  return -EPERM; }

@@ -1487,25 +1494,27 @@ int hdcp2_authenticate_repeater_topology(struct intel_connector *connector) static int hdcp2_authenticate_sink(struct intel_connector *connector) { struct intel_digital_port *intel_dig_port = intel_attached_dig_port(connector);

• struct drm_i915_private *dev_priv = to_i915(connector->base.dev); struct intel_hdcp *hdcp = &connector->hdcp; const struct intel_hdcp_shim *shim = hdcp->shim; int ret;

  ret = hdcp2_authentication_key_exchange(connector); if (ret < 0) {

• DRM_DEBUG_KMS("AKE Failed. Err : %d\n", ret);
  

• drm_dbg_kms(&dev_priv->drm, "AKE Failed. Err : %d\n", ret);
  

  return ret; }

  ret = hdcp2_locality_check(connector); if (ret < 0) {

• DRM_DEBUG_KMS("Locality Check failed. Err : %d\n", ret);
  

• drm_dbg_kms(&dev_priv->drm,
  

• 	    "Locality Check failed. Err : %d\n", ret);
  

  return ret; }

  ret = hdcp2_session_key_exchange(connector); if (ret < 0) {

• DRM_DEBUG_KMS("SKE Failed. Err : %d\n", ret);
  

• drm_dbg_kms(&dev_priv->drm, "SKE Failed. Err : %d\n", ret);
  

  return ret; }

@@ -1520,7 +1529,8 @@ static int hdcp2_authenticate_sink(struct intel_connector *connector) if (hdcp->is_repeater) { ret = hdcp2_authenticate_repeater_topology(connector); if (ret < 0) {

• 	DRM_DEBUG_KMS("Repeater Auth Failed. Err: %d\n", ret);
  

• 	drm_dbg_kms(&dev_priv->drm,
  

• 		    "Repeater Auth Failed. Err: %d\n", ret);
  return ret;
  

  } }

@@ -1651,10 +1661,10 @@ static int hdcp2_authenticate_and_encrypt(struct intel_connector *connector) }

/* Clearing the mei hdcp session */

• DRM_DEBUG_KMS("HDCP2.2 Auth %d of %d Failed.(%d)\n",
  

• 	      i + 1, tries, ret);
  

• drm_dbg_kms(&i915->drm, "HDCP2.2 Auth %d of %d Failed.(%d)\n",
  

• 	    i + 1, tries, ret);
  

  if (hdcp2_deauthenticate_port(connector) < 0)

• 	DRM_DEBUG_KMS("Port deauth failed.\n");
  

• 	drm_dbg_kms(&i915->drm, "Port deauth failed.\n");
  

  }

  if (!ret) {

@@ -1665,9 +1675,10 @@ static int hdcp2_authenticate_and_encrypt(struct intel_connector *connector) msleep(HDCP_2_2_DELAY_BEFORE_ENCRYPTION_EN); ret = hdcp2_enable_encryption(connector); if (ret < 0) {

• 	DRM_DEBUG_KMS("Encryption Enable Failed.(%d)\n", ret);
  

• 	drm_dbg_kms(&i915->drm,
  

• 		    "Encryption Enable Failed.(%d)\n", ret);
  if (hdcp2_deauthenticate_port(connector) < 0)
  

• 		DRM_DEBUG_KMS("Port deauth failed.\n");
  

• 		drm_dbg_kms(&i915->drm, "Port deauth failed.\n");
  

  } }

@@ -1676,23 +1687,24 @@ static int hdcp2_authenticate_and_encrypt(struct intel_connector *connector)

static int _intel_hdcp2_enable(struct intel_connector *connector) {

• struct drm_i915_private *i915 = to_i915(connector->base.dev); struct intel_hdcp *hdcp = &connector->hdcp; int ret;

• DRM_DEBUG_KMS("[%s:%d] HDCP2.2 is being enabled. Type: %d\n",

•       connector->base.name, connector->base.base.id,
  

•       hdcp->content_type);
  

• drm_dbg_kms(&i915->drm, "[%s:%d] HDCP2.2 is being enabled. Type: %d\n",

•     connector->base.name, connector->base.base.id,
  

•     hdcp->content_type);
  
  

  ret = hdcp2_authenticate_and_encrypt(connector); if (ret) {

• DRM_DEBUG_KMS("HDCP2 Type%d  Enabling Failed. (%d)\n",
  

• 	      hdcp->content_type, ret);
  

• drm_dbg_kms(&i915->drm, "HDCP2 Type%d  Enabling Failed. (%d)\n",
  

• 	    hdcp->content_type, ret);
  

  return ret; }

• DRM_DEBUG_KMS("[%s:%d] HDCP2.2 is enabled. Type %d\n",

•       connector->base.name, connector->base.base.id,
  

•       hdcp->content_type);
  

• drm_dbg_kms(&i915->drm, "[%s:%d] HDCP2.2 is enabled. Type %d\n",

•     connector->base.name, connector->base.base.id,
  

•     hdcp->content_type);
  
  

  hdcp->hdcp2_encrypted = true; return 0;

@@ -1700,15 +1712,16 @@ static int _intel_hdcp2_enable(struct intel_connector *connector)

static int _intel_hdcp2_disable(struct intel_connector *connector) {

• struct drm_i915_private *i915 = to_i915(connector->base.dev); int ret;

• DRM_DEBUG_KMS("[%s:%d] HDCP2.2 is being Disabled\n",

•       connector->base.name, connector->base.base.id);
  

• drm_dbg_kms(&i915->drm, "[%s:%d] HDCP2.2 is being Disabled\n",

•     connector->base.name, connector->base.base.id);
  
  

  ret = hdcp2_disable_encryption(connector);

  if (hdcp2_deauthenticate_port(connector) < 0)

• DRM_DEBUG_KMS("Port deauth failed.\n");
  

• drm_dbg_kms(&i915->drm, "Port deauth failed.\n");
  
  

  connector->hdcp.hdcp2_encrypted = false;

@@ -1950,12 +1963,13 @@ void intel_hdcp_component_init(struct drm_i915_private *dev_priv) static void intel_hdcp2_init(struct intel_connector *connector, const struct intel_hdcp_shim *shim) {

• struct drm_i915_private *i915 = to_i915(connector->base.dev); struct intel_hdcp *hdcp = &connector->hdcp; int ret;

  ret = initialize_hdcp_port_data(connector, shim); if (ret) {

• DRM_DEBUG_KMS("Mei hdcp data init failed\n");
  

• drm_dbg_kms(&i915->drm, "Mei hdcp data init failed\n");
  

  return; }