Commit 46df9931 authored by Bhawanpreet Lakha's avatar Bhawanpreet Lakha Committed by Alex Deucher
Browse files

drm/amd/display: Add logging for HDCP2.2 



[Why]
We need to log the state changes for 2.2
This patch extends the existing logging functions to handle
HDCP2.2.

[How]
We do this by adding if/else in the defines, and output the log
 based on the hdcp version

Signed-off-by: default avatarBhawanpreet Lakha <Bhawanpreet.Lakha@amd.com>
Reviewed-by: default avatarHarry Wentland <harry.wentland@amd.com>
Signed-off-by: default avatarAlex Deucher <alexander.deucher@amd.com>
parent 51466b3f

drivers/gpu/drm/amd/display/modules/hdcp/hdcp_log.c

+118 −0
Original line number Diff line number Diff line
@@ -116,6 +116,58 @@ char *mod_hdcp_status_to_str(int32_t status) 
		return "MOD_HDCP_STATUS_DDC_FAILURE";

	case MOD_HDCP_STATUS_INVALID_OPERATION:

		return "MOD_HDCP_STATUS_INVALID_OPERATION";

	case MOD_HDCP_STATUS_HDCP2_NOT_CAPABLE:

		return "MOD_HDCP_STATUS_HDCP2_NOT_CAPABLE";

	case MOD_HDCP_STATUS_HDCP2_CREATE_SESSION_FAILURE:

		return "MOD_HDCP_STATUS_HDCP2_CREATE_SESSION_FAILURE";

	case MOD_HDCP_STATUS_HDCP2_DESTROY_SESSION_FAILURE:

		return "MOD_HDCP_STATUS_HDCP2_DESTROY_SESSION_FAILURE";

	case MOD_HDCP_STATUS_HDCP2_PREP_AKE_INIT_FAILURE:

		return "MOD_HDCP_STATUS_HDCP2_PREP_AKE_INIT_FAILURE";

	case MOD_HDCP_STATUS_HDCP2_AKE_CERT_PENDING:

		return "MOD_HDCP_STATUS_HDCP2_AKE_CERT_PENDING";

	case MOD_HDCP_STATUS_HDCP2_H_PRIME_PENDING:

		return "MOD_HDCP_STATUS_HDCP2_H_PRIME_PENDING";

	case MOD_HDCP_STATUS_HDCP2_PAIRING_INFO_PENDING:

		return "MOD_HDCP_STATUS_HDCP2_PAIRING_INFO_PENDING";

	case MOD_HDCP_STATUS_HDCP2_VALIDATE_AKE_CERT_FAILURE:

		return "MOD_HDCP_STATUS_HDCP2_VALIDATE_AKE_CERT_FAILURE";

	case MOD_HDCP_STATUS_HDCP2_AKE_CERT_REVOKED:

		return "MOD_HDCP_STATUS_HDCP2_AKE_CERT_REVOKED";

	case MOD_HDCP_STATUS_HDCP2_VALIDATE_H_PRIME_FAILURE:

		return "MOD_HDCP_STATUS_HDCP2_VALIDATE_H_PRIME_FAILURE";

	case MOD_HDCP_STATUS_HDCP2_VALIDATE_PAIRING_INFO_FAILURE:

		return "MOD_HDCP_STATUS_HDCP2_VALIDATE_PAIRING_INFO_FAILURE";

	case MOD_HDCP_STATUS_HDCP2_PREP_LC_INIT_FAILURE:

		return "MOD_HDCP_STATUS_HDCP2_PREP_LC_INIT_FAILURE";

	case MOD_HDCP_STATUS_HDCP2_L_PRIME_PENDING:

		return "MOD_HDCP_STATUS_HDCP2_L_PRIME_PENDING";

	case MOD_HDCP_STATUS_HDCP2_VALIDATE_L_PRIME_FAILURE:

		return "MOD_HDCP_STATUS_HDCP2_VALIDATE_L_PRIME_FAILURE";

	case MOD_HDCP_STATUS_HDCP2_PREP_EKS_FAILURE:

		return "MOD_HDCP_STATUS_HDCP2_PREP_EKS_FAILURE";

	case MOD_HDCP_STATUS_HDCP2_ENABLE_ENCRYPTION_FAILURE:

		return "MOD_HDCP_STATUS_HDCP2_ENABLE_ENCRYPTION_FAILURE";

	case MOD_HDCP_STATUS_HDCP2_VALIDATE_RX_ID_LIST_FAILURE:

		return "MOD_HDCP_STATUS_HDCP2_VALIDATE_RX_ID_LIST_FAILURE";

	case MOD_HDCP_STATUS_HDCP2_RX_ID_LIST_REVOKED:

		return "MOD_HDCP_STATUS_HDCP2_RX_ID_LIST_REVOKED";

	case MOD_HDCP_STATUS_HDCP2_RX_ID_LIST_NOT_READY:

		return "MOD_HDCP_STATUS_HDCP2_RX_ID_LIST_NOT_READY";

	case MOD_HDCP_STATUS_HDCP2_ENABLE_STREAM_ENCRYPTION:

		return "MOD_HDCP_STATUS_HDCP2_ENABLE_STREAM_ENCRYPTION";

	case MOD_HDCP_STATUS_HDCP2_STREAM_READY_PENDING:

		return "MOD_HDCP_STATUS_HDCP2_STREAM_READY_PENDING";

	case MOD_HDCP_STATUS_HDCP2_VALIDATE_STREAM_READY_FAILURE:

		return "MOD_HDCP_STATUS_HDCP2_VALIDATE_STREAM_READY_FAILURE";

	case MOD_HDCP_STATUS_HDCP2_PREPARE_STREAM_MANAGEMENT_FAILURE:

		return "MOD_HDCP_STATUS_HDCP2_PREPARE_STREAM_MANAGEMENT_FAILURE";

	case MOD_HDCP_STATUS_HDCP2_REAUTH_REQUEST:

		return "MOD_HDCP_STATUS_HDCP2_REAUTH_REQUEST";

	case MOD_HDCP_STATUS_HDCP2_REAUTH_LINK_INTEGRITY_FAILURE:

		return "MOD_HDCP_STATUS_HDCP2_REAUTH_LINK_INTEGRITY_FAILURE";

	case MOD_HDCP_STATUS_HDCP2_DEVICE_COUNT_MISMATCH_FAILURE:

		return "MOD_HDCP_STATUS_HDCP2_DEVICE_COUNT_MISMATCH_FAILURE";

	default:

		return "MOD_HDCP_STATUS_UNKNOWN";

	}
@@ -156,6 +208,72 @@ char *mod_hdcp_state_id_to_str(int32_t id) 
		return "D1_A6_WAIT_FOR_READY";

	case D1_A7_READ_KSV_LIST:

		return "D1_A7_READ_KSV_LIST";

	case H2_A0_KNOWN_HDCP2_CAPABLE_RX:

		return "H2_A0_KNOWN_HDCP2_CAPABLE_RX";

	case H2_A1_SEND_AKE_INIT:

		return "H2_A1_SEND_AKE_INIT";

	case H2_A1_VALIDATE_AKE_CERT:

		return "H2_A1_VALIDATE_AKE_CERT";

	case H2_A1_SEND_NO_STORED_KM:

		return "H2_A1_SEND_NO_STORED_KM";

	case H2_A1_READ_H_PRIME:

		return "H2_A1_READ_H_PRIME";

	case H2_A1_READ_PAIRING_INFO_AND_VALIDATE_H_PRIME:

		return "H2_A1_READ_PAIRING_INFO_AND_VALIDATE_H_PRIME";

	case H2_A1_SEND_STORED_KM:

		return "H2_A1_SEND_STORED_KM";

	case H2_A1_VALIDATE_H_PRIME:

		return "H2_A1_VALIDATE_H_PRIME";

	case H2_A2_LOCALITY_CHECK:

		return "H2_A2_LOCALITY_CHECK";

	case H2_A3_EXCHANGE_KS_AND_TEST_FOR_REPEATER:

		return "H2_A3_EXCHANGE_KS_AND_TEST_FOR_REPEATER";

	case H2_ENABLE_ENCRYPTION:

		return "H2_ENABLE_ENCRYPTION";

	case H2_A5_AUTHENTICATED:

		return "H2_A5_AUTHENTICATED";

	case H2_A6_WAIT_FOR_RX_ID_LIST:

		return "H2_A6_WAIT_FOR_RX_ID_LIST";

	case H2_A78_VERIFY_RX_ID_LIST_AND_SEND_ACK:

		return "H2_A78_VERIFY_RX_ID_LIST_AND_SEND_ACK";

	case H2_A9_SEND_STREAM_MANAGEMENT:

		return "H2_A9_SEND_STREAM_MANAGEMENT";

	case H2_A9_VALIDATE_STREAM_READY:

		return "H2_A9_VALIDATE_STREAM_READY";

	case D2_A0_DETERMINE_RX_HDCP_CAPABLE:

		return "D2_A0_DETERMINE_RX_HDCP_CAPABLE";

	case D2_A1_SEND_AKE_INIT:

		return "D2_A1_SEND_AKE_INIT";

	case D2_A1_VALIDATE_AKE_CERT:

		return "D2_A1_VALIDATE_AKE_CERT";

	case D2_A1_SEND_NO_STORED_KM:

		return "D2_A1_SEND_NO_STORED_KM";

	case D2_A1_READ_H_PRIME:

		return "D2_A1_READ_H_PRIME";

	case D2_A1_READ_PAIRING_INFO_AND_VALIDATE_H_PRIME:

		return "D2_A1_READ_PAIRING_INFO_AND_VALIDATE_H_PRIME";

	case D2_A1_SEND_STORED_KM:

		return "D2_A1_SEND_STORED_KM";

	case D2_A1_VALIDATE_H_PRIME:

		return "D2_A1_VALIDATE_H_PRIME";

	case D2_A2_LOCALITY_CHECK:

		return "D2_A2_LOCALITY_CHECK";

	case D2_A34_EXCHANGE_KS_AND_TEST_FOR_REPEATER:

		return "D2_A34_EXCHANGE_KS_AND_TEST_FOR_REPEATER";

	case D2_SEND_CONTENT_STREAM_TYPE:

		return "D2_SEND_CONTENT_STREAM_TYPE";

	case D2_ENABLE_ENCRYPTION:

		return "D2_ENABLE_ENCRYPTION";

	case D2_A5_AUTHENTICATED:

		return "D2_A5_AUTHENTICATED";

	case D2_A6_WAIT_FOR_RX_ID_LIST:

		return "D2_A6_WAIT_FOR_RX_ID_LIST";

	case D2_A78_VERIFY_RX_ID_LIST_AND_SEND_ACK:

		return "D2_A78_VERIFY_RX_ID_LIST_AND_SEND_ACK";

	case D2_A9_SEND_STREAM_MANAGEMENT:

		return "D2_A9_SEND_STREAM_MANAGEMENT";

	case D2_A9_VALIDATE_STREAM_READY:

		return "D2_A9_VALIDATE_STREAM_READY";

	default:

		return "UNKNOWN_STATE_ID";

	};

drivers/gpu/drm/amd/display/modules/hdcp/hdcp_log.h

+74 −20
Original line number Diff line number Diff line
@@ -45,6 +45,10 @@ 
		HDCP_LOG_VER(hdcp, \

			"[Link %d] HDCP 1.4 enabled on display %d", \

			hdcp->config.index, displayIndex)

#define HDCP_HDCP2_ENABLED_TRACE(hdcp, displayIndex) \

		HDCP_LOG_VER(hdcp, \

			"[Link %d] HDCP 2.2 enabled on display %d", \

			hdcp->config.index, displayIndex)

/* state machine logs */

#define HDCP_REMOVE_DISPLAY_TRACE(hdcp, displayIndex) \

		HDCP_LOG_FSM(hdcp, \
@@ -93,6 +97,7 @@ 
				hdcp->buf); \

} while (0)

#define HDCP_FULL_DDC_TRACE(hdcp) do { \

	if (is_hdcp1(hdcp)) { \

		HDCP_DDC_READ_TRACE(hdcp, "BKSV", hdcp->auth.msg.hdcp1.bksv, \

				sizeof(hdcp->auth.msg.hdcp1.bksv)); \

		HDCP_DDC_READ_TRACE(hdcp, "BCAPS", &hdcp->auth.msg.hdcp1.bcaps, \
@@ -113,6 +118,52 @@ 
				hdcp->auth.msg.hdcp1.ksvlist_size); \

		HDCP_DDC_READ_TRACE(hdcp, "V'", hdcp->auth.msg.hdcp1.vp, \

				sizeof(hdcp->auth.msg.hdcp1.vp)); \

	} else { \

		HDCP_DDC_READ_TRACE(hdcp, "HDCP2Version", \

				&hdcp->auth.msg.hdcp2.hdcp2version_hdmi, \

				sizeof(hdcp->auth.msg.hdcp2.hdcp2version_hdmi)); \

		HDCP_DDC_READ_TRACE(hdcp, "Rx Caps", hdcp->auth.msg.hdcp2.rxcaps_dp, \

				sizeof(hdcp->auth.msg.hdcp2.rxcaps_dp)); \

		HDCP_DDC_WRITE_TRACE(hdcp, "AKE Init", hdcp->auth.msg.hdcp2.ake_init, \

				sizeof(hdcp->auth.msg.hdcp2.ake_init)); \

		HDCP_DDC_READ_TRACE(hdcp, "AKE Cert", hdcp->auth.msg.hdcp2.ake_cert, \

				sizeof(hdcp->auth.msg.hdcp2.ake_cert)); \

		HDCP_DDC_WRITE_TRACE(hdcp, "Stored KM", \

				hdcp->auth.msg.hdcp2.ake_stored_km, \

				sizeof(hdcp->auth.msg.hdcp2.ake_stored_km)); \

		HDCP_DDC_WRITE_TRACE(hdcp, "No Stored KM", \

				hdcp->auth.msg.hdcp2.ake_no_stored_km, \

				sizeof(hdcp->auth.msg.hdcp2.ake_no_stored_km)); \

		HDCP_DDC_READ_TRACE(hdcp, "H'", hdcp->auth.msg.hdcp2.ake_h_prime, \

				sizeof(hdcp->auth.msg.hdcp2.ake_h_prime)); \

		HDCP_DDC_READ_TRACE(hdcp, "Pairing Info", \

				hdcp->auth.msg.hdcp2.ake_pairing_info, \

				sizeof(hdcp->auth.msg.hdcp2.ake_pairing_info)); \

		HDCP_DDC_WRITE_TRACE(hdcp, "LC Init", hdcp->auth.msg.hdcp2.lc_init, \

				sizeof(hdcp->auth.msg.hdcp2.lc_init)); \

		HDCP_DDC_READ_TRACE(hdcp, "L'", hdcp->auth.msg.hdcp2.lc_l_prime, \

				sizeof(hdcp->auth.msg.hdcp2.lc_l_prime)); \

		HDCP_DDC_WRITE_TRACE(hdcp, "Exchange KS", hdcp->auth.msg.hdcp2.ske_eks, \

				sizeof(hdcp->auth.msg.hdcp2.ske_eks)); \

		HDCP_DDC_READ_TRACE(hdcp, "Rx Status", \

				(uint8_t *)&hdcp->auth.msg.hdcp2.rxstatus, \

				sizeof(hdcp->auth.msg.hdcp2.rxstatus)); \

		HDCP_DDC_READ_TRACE(hdcp, "Rx Id List", \

				hdcp->auth.msg.hdcp2.rx_id_list, \

				hdcp->auth.msg.hdcp2.rx_id_list_size); \

		HDCP_DDC_WRITE_TRACE(hdcp, "Rx Id List Ack", \

				hdcp->auth.msg.hdcp2.repeater_auth_ack, \

				sizeof(hdcp->auth.msg.hdcp2.repeater_auth_ack)); \

		HDCP_DDC_WRITE_TRACE(hdcp, "Content Stream Management", \

				hdcp->auth.msg.hdcp2.repeater_auth_stream_manage, \

				hdcp->auth.msg.hdcp2.stream_manage_size); \

		HDCP_DDC_READ_TRACE(hdcp, "Stream Ready", \

				hdcp->auth.msg.hdcp2.repeater_auth_stream_ready, \

				sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_ready)); \

		HDCP_DDC_WRITE_TRACE(hdcp, "Content Stream Type", \

				hdcp->auth.msg.hdcp2.content_stream_type_dp, \

				sizeof(hdcp->auth.msg.hdcp2.content_stream_type_dp)); \

	} \

} while (0)

#define HDCP_TOP_ADD_DISPLAY_TRACE(hdcp, i) \

		HDCP_LOG_TOP(hdcp, "[Link %d]\tadd display %d", \
@@ -123,6 +174,9 @@ 
#define HDCP_TOP_HDCP1_DESTROY_SESSION_TRACE(hdcp) \

		HDCP_LOG_TOP(hdcp, "[Link %d]\tdestroy hdcp1 session", \

				hdcp->config.index)

#define HDCP_TOP_HDCP2_DESTROY_SESSION_TRACE(hdcp) \

		HDCP_LOG_TOP(hdcp, "[Link %d]\tdestroy hdcp2 session", \

				hdcp->config.index)

#define HDCP_TOP_RESET_AUTH_TRACE(hdcp) \

		HDCP_LOG_TOP(hdcp, "[Link %d]\treset authentication", hdcp->config.index)

#define HDCP_TOP_RESET_CONN_TRACE(hdcp) \

drivers/gpu/drm/amd/display/modules/hdcp/hdcp_psp.c

+4 −0
Original line number Diff line number Diff line
@@ -393,6 +393,8 @@ enum mod_hdcp_status mod_hdcp_hdcp2_destroy_session(struct mod_hdcp *hdcp) 
	if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)

		return MOD_HDCP_STATUS_HDCP2_DESTROY_SESSION_FAILURE;



	HDCP_TOP_HDCP2_DESTROY_SESSION_TRACE(hdcp);



	return MOD_HDCP_STATUS_SUCCESS;

}
@@ -649,6 +651,7 @@ enum mod_hdcp_status mod_hdcp_hdcp2_enable_encryption(struct mod_hdcp *hdcp) 


	if (!is_dp_mst_hdcp(hdcp)) {

		display->state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;

		HDCP_HDCP2_ENABLED_TRACE(hdcp, display->index);

	}



	return MOD_HDCP_STATUS_SUCCESS;
@@ -727,6 +730,7 @@ enum mod_hdcp_status mod_hdcp_hdcp2_enable_dp_stream_encryption(struct mod_hdcp 
			break;



		hdcp->connection.displays[i].state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;

		HDCP_HDCP2_ENABLED_TRACE(hdcp, hdcp->connection.displays[i].index);

	}



	return (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS) ? MOD_HDCP_STATUS_SUCCESS

CRA Git | Maintained and supported by SUSTech CRA and CCSE