diff options
Diffstat (limited to 'meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.19.8/4500-drm-amd-display-Add-PSP-block-to-verify-HDCP2.2-step.patch')
-rw-r--r-- | meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.19.8/4500-drm-amd-display-Add-PSP-block-to-verify-HDCP2.2-step.patch | 863 |
1 files changed, 863 insertions, 0 deletions
diff --git a/meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.19.8/4500-drm-amd-display-Add-PSP-block-to-verify-HDCP2.2-step.patch b/meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.19.8/4500-drm-amd-display-Add-PSP-block-to-verify-HDCP2.2-step.patch new file mode 100644 index 00000000..42e9d2af --- /dev/null +++ b/meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.19.8/4500-drm-amd-display-Add-PSP-block-to-verify-HDCP2.2-step.patch @@ -0,0 +1,863 @@ +From 960ca96c1baf29d4050e20323e0a8ac78b018125 Mon Sep 17 00:00:00 2001 +From: Bhawanpreet Lakha <Bhawanpreet.Lakha@amd.com> +Date: Wed, 18 Sep 2019 11:19:51 -0400 +Subject: [PATCH 4500/4736] drm/amd/display: Add PSP block to verify HDCP2.2 + steps + +[Why] +All the HDCP transactions should be verified using PSP + +[How] +This patch adds the psp calls we need to verify the steps + +Signed-off-by: Bhawanpreet Lakha <Bhawanpreet.Lakha@amd.com> +Reviewed-by: Harry Wentland <harry.wentland@amd.com> +--- + .../gpu/drm/amd/display/modules/hdcp/hdcp.h | 44 ++ + .../drm/amd/display/modules/hdcp/hdcp_psp.c | 502 +++++++++++++++++- + .../drm/amd/display/modules/hdcp/hdcp_psp.h | 194 +++++++ + 3 files changed, 739 insertions(+), 1 deletion(-) + +diff --git a/drivers/gpu/drm/amd/display/modules/hdcp/hdcp.h b/drivers/gpu/drm/amd/display/modules/hdcp/hdcp.h +index 5664bc0b5bd0..d83f0ab1cadb 100644 +--- a/drivers/gpu/drm/amd/display/modules/hdcp/hdcp.h ++++ b/drivers/gpu/drm/amd/display/modules/hdcp/hdcp.h +@@ -111,8 +111,33 @@ struct mod_hdcp_message_hdcp1 { + uint16_t binfo_dp; + }; + ++struct mod_hdcp_message_hdcp2 { ++ uint8_t hdcp2version_hdmi; ++ uint8_t rxcaps_dp[3]; ++ uint16_t rxstatus; ++ ++ uint8_t ake_init[12]; ++ uint8_t ake_cert[534]; ++ uint8_t ake_no_stored_km[129]; ++ uint8_t ake_stored_km[33]; ++ uint8_t ake_h_prime[33]; ++ uint8_t ake_pairing_info[17]; ++ uint8_t lc_init[9]; ++ uint8_t lc_l_prime[33]; ++ uint8_t ske_eks[25]; ++ uint8_t rx_id_list[177]; // 22 + 5 * 31 ++ uint16_t rx_id_list_size; ++ uint8_t repeater_auth_ack[17]; ++ uint8_t repeater_auth_stream_manage[68]; // 6 + 2 * 31 ++ uint16_t stream_manage_size; ++ uint8_t repeater_auth_stream_ready[33]; ++ ++ uint8_t content_stream_type_dp[2]; ++}; ++ + union mod_hdcp_message { + struct mod_hdcp_message_hdcp1 hdcp1; ++ struct mod_hdcp_message_hdcp2 hdcp2; + }; + + struct mod_hdcp_auth_counters { +@@ -234,6 +259,25 @@ enum mod_hdcp_status mod_hdcp_hdcp1_enable_dp_stream_encryption( + enum mod_hdcp_status mod_hdcp_hdcp1_link_maintenance(struct mod_hdcp *hdcp); + enum mod_hdcp_status mod_hdcp_hdcp1_get_link_encryption_status(struct mod_hdcp *hdcp, + enum mod_hdcp_encryption_status *encryption_status); ++enum mod_hdcp_status mod_hdcp_hdcp2_create_session(struct mod_hdcp *hdcp); ++enum mod_hdcp_status mod_hdcp_hdcp2_destroy_session(struct mod_hdcp *hdcp); ++enum mod_hdcp_status mod_hdcp_hdcp2_prepare_ake_init(struct mod_hdcp *hdcp); ++enum mod_hdcp_status mod_hdcp_hdcp2_validate_ake_cert(struct mod_hdcp *hdcp); ++enum mod_hdcp_status mod_hdcp_hdcp2_validate_h_prime(struct mod_hdcp *hdcp); ++enum mod_hdcp_status mod_hdcp_hdcp2_prepare_lc_init(struct mod_hdcp *hdcp); ++enum mod_hdcp_status mod_hdcp_hdcp2_validate_l_prime(struct mod_hdcp *hdcp); ++enum mod_hdcp_status mod_hdcp_hdcp2_prepare_eks(struct mod_hdcp *hdcp); ++enum mod_hdcp_status mod_hdcp_hdcp2_enable_encryption(struct mod_hdcp *hdcp); ++enum mod_hdcp_status mod_hdcp_hdcp2_validate_rx_id_list(struct mod_hdcp *hdcp); ++enum mod_hdcp_status mod_hdcp_hdcp2_enable_dp_stream_encryption( ++ struct mod_hdcp *hdcp); ++enum mod_hdcp_status mod_hdcp_hdcp2_prepare_stream_management( ++ struct mod_hdcp *hdcp); ++enum mod_hdcp_status mod_hdcp_hdcp2_validate_stream_ready( ++ struct mod_hdcp *hdcp); ++enum mod_hdcp_status mod_hdcp_hdcp2_get_link_encryption_status(struct mod_hdcp *hdcp, ++ enum mod_hdcp_encryption_status *encryption_status); ++ + /* ddc functions */ + enum mod_hdcp_status mod_hdcp_read_bksv(struct mod_hdcp *hdcp); + enum mod_hdcp_status mod_hdcp_read_bcaps(struct mod_hdcp *hdcp); +diff --git a/drivers/gpu/drm/amd/display/modules/hdcp/hdcp_psp.c b/drivers/gpu/drm/amd/display/modules/hdcp/hdcp_psp.c +index 646d909bbc37..ddba0cfa5722 100644 +--- a/drivers/gpu/drm/amd/display/modules/hdcp/hdcp_psp.c ++++ b/drivers/gpu/drm/amd/display/modules/hdcp/hdcp_psp.c +@@ -31,6 +31,19 @@ + #include "amdgpu.h" + #include "hdcp_psp.h" + ++static void hdcp2_message_init(struct mod_hdcp *hdcp, ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *in) ++{ ++ in->session_handle = hdcp->auth.id; ++ in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE; ++ in->prepare.msg2_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE; ++ in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE; ++ in->process.msg1_desc.msg_size = 0; ++ in->process.msg2_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE; ++ in->process.msg2_desc.msg_size = 0; ++ in->process.msg3_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE; ++ in->process.msg3_desc.msg_id = 0; ++} + enum mod_hdcp_status mod_hdcp_remove_display_topology(struct mod_hdcp *hdcp) + { + +@@ -42,7 +55,7 @@ enum mod_hdcp_status mod_hdcp_remove_display_topology(struct mod_hdcp *hdcp) + dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.dtm_shared_buf; + + for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) { +- if (hdcp->connection.displays[i].state == MOD_HDCP_DISPLAY_ACTIVE_AND_ADDED) { ++ if (is_display_added(&(hdcp->connection.displays[i]))) { + + memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory)); + +@@ -326,3 +339,490 @@ enum mod_hdcp_status mod_hdcp_hdcp1_get_link_encryption_status(struct mod_hdcp * + return MOD_HDCP_STATUS_SUCCESS; + } + ++enum mod_hdcp_status mod_hdcp_hdcp2_create_session(struct mod_hdcp *hdcp) ++{ ++ struct psp_context *psp = hdcp->config.psp.handle; ++ struct ta_hdcp_shared_memory *hdcp_cmd; ++ struct mod_hdcp_display *display = get_first_added_display(hdcp); ++ ++ if (!psp->hdcp_context.hdcp_initialized) { ++ DRM_ERROR("Failed to create hdcp session, HDCP TA is not initialized"); ++ return MOD_HDCP_STATUS_FAILURE; ++ } ++ ++ hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; ++ memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); ++ ++ if (!display) ++ return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND; ++ ++ hdcp_cmd->in_msg.hdcp2_create_session_v2.display_handle = display->index; ++ ++ if (hdcp->connection.link.adjust.hdcp2.disable_type1) ++ hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type = ++ TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__FORCE_TYPE0; ++ else ++ hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type = ++ TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__MAX_SUPPORTED; ++ ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_CREATE_SESSION_V2; ++ ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP2_CREATE_SESSION_FAILURE; ++ ++ hdcp->auth.id = hdcp_cmd->out_msg.hdcp2_create_session_v2.session_handle; ++ ++ return MOD_HDCP_STATUS_SUCCESS; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp2_destroy_session(struct mod_hdcp *hdcp) ++{ ++ struct psp_context *psp = hdcp->config.psp.handle; ++ struct ta_hdcp_shared_memory *hdcp_cmd; ++ ++ hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; ++ memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); ++ ++ hdcp_cmd->in_msg.hdcp2_destroy_session.session_handle = hdcp->auth.id; ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_DESTROY_SESSION; ++ ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP2_DESTROY_SESSION_FAILURE; ++ ++ return MOD_HDCP_STATUS_SUCCESS; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp2_prepare_ake_init(struct mod_hdcp *hdcp) ++{ ++ struct psp_context *psp = hdcp->config.psp.handle; ++ struct ta_hdcp_shared_memory *hdcp_cmd; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; ++ ++ hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; ++ memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); ++ ++ msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; ++ msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; ++ ++ hdcp2_message_init(hdcp, msg_in); ++ ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; ++ msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__AKE_INIT; ++ ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP2_PREP_AKE_INIT_FAILURE; ++ ++ memcpy(&hdcp->auth.msg.hdcp2.ake_init[0], &msg_out->prepare.transmitter_message[0], ++ sizeof(hdcp->auth.msg.hdcp2.ake_init)); ++ ++ return MOD_HDCP_STATUS_SUCCESS; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp2_validate_ake_cert(struct mod_hdcp *hdcp) ++{ ++ struct psp_context *psp = hdcp->config.psp.handle; ++ struct ta_hdcp_shared_memory *hdcp_cmd; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; ++ ++ hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; ++ memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); ++ ++ msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; ++ msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; ++ ++ hdcp2_message_init(hdcp, msg_in); ++ ++ msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_CERT; ++ msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_CERT; ++ ++ memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.ake_cert, ++ sizeof(hdcp->auth.msg.hdcp2.ake_cert)); ++ ++ msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__AKE_NO_STORED_KM; ++ msg_in->prepare.msg2_id = TA_HDCP_HDCP2_MSG_ID__AKE_STORED_KM; ++ ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; ++ ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP2_VALIDATE_AKE_CERT_FAILURE; ++ ++ memcpy(hdcp->auth.msg.hdcp2.ake_no_stored_km, &msg_out->prepare.transmitter_message[0], ++ sizeof(hdcp->auth.msg.hdcp2.ake_no_stored_km)); ++ ++ memcpy(hdcp->auth.msg.hdcp2.ake_stored_km, ++ &msg_out->prepare.transmitter_message[sizeof(hdcp->auth.msg.hdcp2.ake_no_stored_km)], ++ sizeof(hdcp->auth.msg.hdcp2.ake_stored_km)); ++ ++ if (msg_out->process.msg1_status == TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) { ++ hdcp->connection.is_km_stored = msg_out->process.is_km_stored ? 1 : 0; ++ hdcp->connection.is_repeater = msg_out->process.is_repeater ? 1 : 0; ++ return MOD_HDCP_STATUS_SUCCESS; ++ } ++ ++ return MOD_HDCP_STATUS_FAILURE; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp2_validate_h_prime(struct mod_hdcp *hdcp) ++{ ++ struct psp_context *psp = hdcp->config.psp.handle; ++ struct ta_hdcp_shared_memory *hdcp_cmd; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; ++ ++ hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; ++ memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); ++ ++ msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; ++ msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; ++ ++ hdcp2_message_init(hdcp, msg_in); ++ ++ msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_H_PRIME; ++ msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_H_PRIME; ++ ++ memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.ake_h_prime, ++ sizeof(hdcp->auth.msg.hdcp2.ake_h_prime)); ++ ++ if (!hdcp->connection.is_km_stored) { ++ msg_in->process.msg2_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_PAIRING_INFO; ++ msg_in->process.msg2_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_PAIRING_INFO; ++ memcpy(&msg_in->process.receiver_message[sizeof(hdcp->auth.msg.hdcp2.ake_h_prime)], ++ hdcp->auth.msg.hdcp2.ake_pairing_info, sizeof(hdcp->auth.msg.hdcp2.ake_pairing_info)); ++ } ++ ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; ++ ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP2_VALIDATE_AKE_CERT_FAILURE; ++ ++ if (msg_out->process.msg1_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP2_VALIDATE_H_PRIME_FAILURE; ++ else if (!hdcp->connection.is_km_stored && ++ msg_out->process.msg2_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP2_VALIDATE_PAIRING_INFO_FAILURE; ++ ++ ++ return MOD_HDCP_STATUS_SUCCESS; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp2_prepare_lc_init(struct mod_hdcp *hdcp) ++{ ++ struct psp_context *psp = hdcp->config.psp.handle; ++ struct ta_hdcp_shared_memory *hdcp_cmd; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; ++ ++ hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; ++ memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); ++ ++ msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; ++ msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; ++ ++ hdcp2_message_init(hdcp, msg_in); ++ ++ msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__LC_INIT; ++ ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; ++ ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP2_PREP_LC_INIT_FAILURE; ++ ++ memcpy(hdcp->auth.msg.hdcp2.lc_init, &msg_out->prepare.transmitter_message[0], ++ sizeof(hdcp->auth.msg.hdcp2.lc_init)); ++ ++ return MOD_HDCP_STATUS_SUCCESS; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp2_validate_l_prime(struct mod_hdcp *hdcp) ++{ ++ struct psp_context *psp = hdcp->config.psp.handle; ++ struct ta_hdcp_shared_memory *hdcp_cmd; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; ++ ++ hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; ++ memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); ++ ++ msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; ++ msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; ++ ++ hdcp2_message_init(hdcp, msg_in); ++ ++ msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__LC_SEND_L_PRIME; ++ msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__LC_SEND_L_PRIME; ++ ++ memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.lc_l_prime, ++ sizeof(hdcp->auth.msg.hdcp2.lc_l_prime)); ++ ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; ++ ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP2_VALIDATE_L_PRIME_FAILURE; ++ ++ if (msg_out->process.msg1_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP2_VALIDATE_L_PRIME_FAILURE; ++ ++ return MOD_HDCP_STATUS_SUCCESS; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp2_prepare_eks(struct mod_hdcp *hdcp) ++{ ++ struct psp_context *psp = hdcp->config.psp.handle; ++ struct ta_hdcp_shared_memory *hdcp_cmd; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; ++ ++ hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; ++ memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); ++ ++ msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; ++ msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; ++ ++ hdcp2_message_init(hdcp, msg_in); ++ ++ msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__SKE_SEND_EKS; ++ ++ if (is_dp_hdcp(hdcp)) ++ msg_in->prepare.msg2_id = TA_HDCP_HDCP2_MSG_ID__SIGNAL_CONTENT_STREAM_TYPE_DP; ++ ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP2_PREP_EKS_FAILURE; ++ ++ memcpy(hdcp->auth.msg.hdcp2.ske_eks, &msg_out->prepare.transmitter_message[0], ++ sizeof(hdcp->auth.msg.hdcp2.ske_eks)); ++ msg_out->prepare.msg1_desc.msg_size = sizeof(hdcp->auth.msg.hdcp2.ske_eks); ++ ++ if (is_dp_hdcp(hdcp)) { ++ memcpy(hdcp->auth.msg.hdcp2.content_stream_type_dp, ++ &msg_out->prepare.transmitter_message[sizeof(hdcp->auth.msg.hdcp2.ske_eks)], ++ sizeof(hdcp->auth.msg.hdcp2.content_stream_type_dp)); ++ } ++ ++ return MOD_HDCP_STATUS_SUCCESS; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp2_enable_encryption(struct mod_hdcp *hdcp) ++{ ++ struct psp_context *psp = hdcp->config.psp.handle; ++ struct ta_hdcp_shared_memory *hdcp_cmd; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; ++ struct mod_hdcp_display *display = get_first_added_display(hdcp); ++ ++ hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; ++ memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); ++ ++ msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; ++ msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; ++ ++ hdcp2_message_init(hdcp, msg_in); ++ ++ if (!display) ++ return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND; ++ ++ hdcp_cmd->in_msg.hdcp1_enable_encryption.session_handle = hdcp->auth.id; ++ ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_SET_ENCRYPTION; ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP2_ENABLE_ENCRYPTION_FAILURE; ++ ++ if (!is_dp_mst_hdcp(hdcp)) { ++ display->state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED; ++ } ++ ++ return MOD_HDCP_STATUS_SUCCESS; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp2_validate_rx_id_list(struct mod_hdcp *hdcp) ++{ ++ struct psp_context *psp = hdcp->config.psp.handle; ++ struct ta_hdcp_shared_memory *hdcp_cmd; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; ++ ++ hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; ++ memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); ++ ++ msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; ++ msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; ++ ++ hdcp2_message_init(hdcp, msg_in); ++ ++ msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_SEND_RECEIVERID_LIST; ++ msg_in->process.msg1_desc.msg_size = sizeof(hdcp->auth.msg.hdcp2.rx_id_list); ++ memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.rx_id_list, ++ sizeof(hdcp->auth.msg.hdcp2.rx_id_list)); ++ ++ msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_SEND_ACK; ++ ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; ++ ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP2_VALIDATE_RX_ID_LIST_FAILURE; ++ ++ memcpy(hdcp->auth.msg.hdcp2.repeater_auth_ack, &msg_out->prepare.transmitter_message[0], ++ sizeof(hdcp->auth.msg.hdcp2.repeater_auth_ack)); ++ ++ if (msg_out->process.msg1_status == TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) { ++ hdcp->connection.is_km_stored = msg_out->process.is_km_stored ? 1 : 0; ++ hdcp->connection.is_repeater = msg_out->process.is_repeater ? 1 : 0; ++ return MOD_HDCP_STATUS_SUCCESS; ++ } ++ ++ ++ return MOD_HDCP_STATUS_HDCP2_VALIDATE_RX_ID_LIST_FAILURE; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp2_enable_dp_stream_encryption(struct mod_hdcp *hdcp) ++{ ++ struct psp_context *psp = hdcp->config.psp.handle; ++ struct ta_hdcp_shared_memory *hdcp_cmd; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; ++ uint8_t i; ++ ++ hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; ++ memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); ++ ++ msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; ++ msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; ++ ++ hdcp2_message_init(hdcp, msg_in); ++ ++ ++ for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) { ++ if (hdcp->connection.displays[i].state != MOD_HDCP_DISPLAY_ACTIVE_AND_ADDED || ++ hdcp->connection.displays[i].adjust.disable) ++ continue; ++ hdcp_cmd->in_msg.hdcp2_enable_dp_stream_encryption.display_handle = hdcp->connection.displays[i].index; ++ hdcp_cmd->in_msg.hdcp2_enable_dp_stream_encryption.session_handle = hdcp->auth.id; ++ ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_ENABLE_DP_STREAM_ENCRYPTION; ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ break; ++ ++ hdcp->connection.displays[i].state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED; ++ } ++ ++ return (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS) ? MOD_HDCP_STATUS_SUCCESS ++ : MOD_HDCP_STATUS_HDCP2_ENABLE_STREAM_ENCRYPTION; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp2_prepare_stream_management(struct mod_hdcp *hdcp) ++{ ++ ++ struct psp_context *psp = hdcp->config.psp.handle; ++ struct ta_hdcp_shared_memory *hdcp_cmd; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; ++ ++ hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; ++ memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); ++ ++ msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; ++ msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; ++ ++ hdcp2_message_init(hdcp, msg_in); ++ ++ msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_STREAM_MANAGE; ++ ++ ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP2_PREPARE_STREAM_MANAGEMENT_FAILURE; ++ ++ hdcp->auth.msg.hdcp2.stream_manage_size = msg_out->prepare.msg1_desc.msg_size; ++ ++ memcpy(hdcp->auth.msg.hdcp2.repeater_auth_stream_manage, &msg_out->prepare.transmitter_message[0], ++ sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_manage)); ++ ++ return MOD_HDCP_STATUS_SUCCESS; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp2_validate_stream_ready(struct mod_hdcp *hdcp) ++{ ++ struct psp_context *psp = hdcp->config.psp.handle; ++ struct ta_hdcp_shared_memory *hdcp_cmd; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; ++ ++ hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; ++ memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); ++ ++ msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; ++ msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; ++ ++ hdcp2_message_init(hdcp, msg_in); ++ ++ msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_STREAM_READY; ++ ++ msg_in->process.msg1_desc.msg_size = sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_ready); ++ ++ memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.repeater_auth_stream_ready, ++ sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_ready)); ++ ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ return (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) && ++ (msg_out->process.msg1_status == TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) ++ ? MOD_HDCP_STATUS_SUCCESS ++ : MOD_HDCP_STATUS_HDCP2_VALIDATE_STREAM_READY_FAILURE; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp2_get_link_encryption_status(struct mod_hdcp *hdcp, ++ enum mod_hdcp_encryption_status *encryption_status) ++{ ++ struct psp_context *psp = hdcp->config.psp.handle; ++ struct ta_hdcp_shared_memory *hdcp_cmd; ++ ++ hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; ++ ++ memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); ++ ++ hdcp_cmd->in_msg.hdcp2_get_encryption_status.session_handle = hdcp->auth.id; ++ hdcp_cmd->out_msg.hdcp2_get_encryption_status.protection_level = 0; ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_GET_ENCRYPTION_STATUS; ++ *encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF; ++ ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_FAILURE; ++ ++ if (hdcp_cmd->out_msg.hdcp2_get_encryption_status.protection_level == 1) { ++ if (hdcp_cmd->out_msg.hdcp2_get_encryption_status.hdcp2_type == TA_HDCP2_CONTENT_TYPE__TYPE1) ++ *encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON; ++ else ++ *encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE0_ON; ++ } ++ ++ return MOD_HDCP_STATUS_SUCCESS; ++} +diff --git a/drivers/gpu/drm/amd/display/modules/hdcp/hdcp_psp.h b/drivers/gpu/drm/amd/display/modules/hdcp/hdcp_psp.h +index 986fc07ea9ea..82a5e997d573 100644 +--- a/drivers/gpu/drm/amd/display/modules/hdcp/hdcp_psp.h ++++ b/drivers/gpu/drm/amd/display/modules/hdcp/hdcp_psp.h +@@ -36,6 +36,11 @@ enum bgd_security_hdcp_encryption_level { + HDCP_ENCRYPTION_LEVEL__ON + }; + ++enum bgd_security_hdcp2_content_type { ++ HDCP2_CONTENT_TYPE__INVALID = 0, ++ HDCP2_CONTENT_TYPE__TYPE0, ++ HDCP2_CONTENT_TYPE__TYPE1 ++}; + enum ta_dtm_command { + TA_DTM_COMMAND__UNUSED_1 = 1, + TA_DTM_COMMAND__TOPOLOGY_UPDATE_V2, +@@ -121,8 +126,64 @@ enum ta_hdcp_command { + TA_HDCP_COMMAND__HDCP1_ENABLE_ENCRYPTION, + TA_HDCP_COMMAND__HDCP1_ENABLE_DP_STREAM_ENCRYPTION, + TA_HDCP_COMMAND__HDCP1_GET_ENCRYPTION_STATUS, ++ TA_HDCP_COMMAND__UNUSED_1, ++ TA_HDCP_COMMAND__HDCP2_DESTROY_SESSION, ++ TA_HDCP_COMMAND__UNUSED_2, ++ TA_HDCP_COMMAND__HDCP2_SET_ENCRYPTION, ++ TA_HDCP_COMMAND__HDCP2_GET_ENCRYPTION_STATUS, ++ TA_HDCP_COMMAND__UNUSED_3, ++ TA_HDCP_COMMAND__HDCP2_CREATE_SESSION_V2, ++ TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2, ++ TA_HDCP_COMMAND__HDCP2_ENABLE_DP_STREAM_ENCRYPTION ++}; ++ ++enum ta_hdcp2_msg_id { ++ TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE = 1, ++ TA_HDCP_HDCP2_MSG_ID__AKE_INIT = 2, ++ TA_HDCP_HDCP2_MSG_ID__AKE_SEND_CERT = 3, ++ TA_HDCP_HDCP2_MSG_ID__AKE_NO_STORED_KM = 4, ++ TA_HDCP_HDCP2_MSG_ID__AKE_STORED_KM = 5, ++ TA_HDCP_HDCP2_MSG_ID__AKE_SEND_RRX = 6, ++ TA_HDCP_HDCP2_MSG_ID__AKE_SEND_H_PRIME = 7, ++ TA_HDCP_HDCP2_MSG_ID__AKE_SEND_PAIRING_INFO = 8, ++ TA_HDCP_HDCP2_MSG_ID__LC_INIT = 9, ++ TA_HDCP_HDCP2_MSG_ID__LC_SEND_L_PRIME = 10, ++ TA_HDCP_HDCP2_MSG_ID__SKE_SEND_EKS = 11, ++ TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_SEND_RECEIVERID_LIST = 12, ++ TA_HDCP_HDCP2_MSG_ID__RTT_READY = 13, ++ TA_HDCP_HDCP2_MSG_ID__RTT_CHALLENGE = 14, ++ TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_SEND_ACK = 15, ++ TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_STREAM_MANAGE = 16, ++ TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_STREAM_READY = 17, ++ TA_HDCP_HDCP2_MSG_ID__RECEIVER_AUTH_STATUS = 18, ++ TA_HDCP_HDCP2_MSG_ID__AKE_TRANSMITTER_INFO = 19, ++ TA_HDCP_HDCP2_MSG_ID__AKE_RECEIVER_INFO = 20, ++ TA_HDCP_HDCP2_MSG_ID__SIGNAL_CONTENT_STREAM_TYPE_DP = 129 + }; + ++enum ta_hdcp2_hdcp2_msg_id_max_size { ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__NULL_MESSAGE = 0, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_INIT = 12, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_CERT = 534, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_NO_STORED_KM = 129, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_STORED_KM = 33, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_RRX = 9, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_H_PRIME = 33, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_PAIRING_INFO = 17, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__LC_INIT = 9, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__LC_SEND_L_PRIME = 33, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__SKE_SEND_EKS = 25, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__REPEATERAUTH_SEND_RECEIVERID_LIST = 181, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__RTT_READY = 1, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__RTT_CHALLENGE = 17, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__REPEATERAUTH_SEND_RACK = 17, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__REPEATERAUTH_STREAM_MANAGE = 13, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__REPEATERAUTH_STREAM_READY = 33, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__RECEIVER_AUTH_STATUS = 4, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_TRANSMITTER_INFO = 6, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_RECEIVER_INFO = 6, ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__SIGNAL_CONTENT_STREAM_TYPE_DP = 1 ++}; + + /* HDCP related enumerations */ + /**********************************************************/ +@@ -131,6 +192,12 @@ enum ta_hdcp_command { + #define TA_HDCP__HDCP1_KSV_SIZE 5 + #define TA_HDCP__HDCP1_KSV_LIST_MAX_ENTRIES 127 + #define TA_HDCP__HDCP1_V_PRIME_SIZE 20 ++#define TA_HDCP__HDCP2_TX_BUF_MAX_SIZE \ ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_NO_STORED_KM + TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_STORED_KM + 6 ++ ++// 64 bits boundaries ++#define TA_HDCP__HDCP2_RX_BUF_MAX_SIZE \ ++ TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_CERT + TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_RECEIVER_INFO + 4 + + enum ta_hdcp_status { + TA_HDCP_STATUS__SUCCESS = 0x00, +@@ -165,9 +232,47 @@ enum ta_hdcp_authentication_status { + TA_HDCP_AUTHENTICATION_STATUS__HDCP1_FIRST_PART_COMPLETE = 0x02, + TA_HDCP_AUTHENTICATION_STATUS__HDCP1_SECOND_PART_FAILED = 0x03, + TA_HDCP_AUTHENTICATION_STATUS__HDCP1_AUTHENTICATED = 0x04, ++ TA_HDCP_AUTHENTICATION_STATUS__HDCP22_AUTHENTICATION_PENDING = 0x06, ++ TA_HDCP_AUTHENTICATION_STATUS__HDCP22_AUTHENTICATION_FAILED = 0x07, ++ TA_HDCP_AUTHENTICATION_STATUS__HDCP22_AUTHENTICATED = 0x08, + TA_HDCP_AUTHENTICATION_STATUS__HDCP1_KSV_VALIDATION_FAILED = 0x09 + }; + ++enum ta_hdcp2_msg_authentication_status { ++ TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS = 0, ++ TA_HDCP2_MSG_AUTHENTICATION_STATUS__KM_NOT_AVAILABLE, ++ TA_HDCP2_MSG_AUTHENTICATION_STATUS__UNUSED, ++ TA_HDCP2_MSG_AUTHENTICATION_STATUS__INVALID = 100, // everything above does not fail the request ++ TA_HDCP2_MSG_AUTHENTICATION_STATUS__NOT_ENOUGH_MEMORY, ++ TA_HDCP2_MSG_AUTHENTICATION_STATUS__NOT_EXPECTED_MSG, ++ TA_HDCP2_MSG_AUTHENTICATION_STATUS__SIGNATURE_CERTIFICAT_ERROR, ++ TA_HDCP2_MSG_AUTHENTICATION_STATUS__INCORRECT_HDCP_VERSION, ++ TA_HDCP2_MSG_AUTHENTICATION_STATUS__UNKNOWN_MESSAGE, ++ TA_HDCP2_MSG_AUTHENTICATION_STATUS__INVALID_HMAC, ++ TA_HDCP2_MSG_AUTHENTICATION_STATUS__INVALID_TOPOLOGY, ++ TA_HDCP2_MSG_AUTHENTICATION_STATUS__INVALID_SEQ_NUM, ++ TA_HDCP2_MSG_AUTHENTICATION_STATUS__INVALID_SIZE, ++ TA_HDCP2_MSG_AUTHENTICATION_STATUS__INVALID_LENGTH, ++ TA_HDCP2_MSG_AUTHENTICATION_STATUS__REAUTH_REQUEST ++}; ++ ++enum ta_hdcp_content_type { ++ TA_HDCP2_CONTENT_TYPE__TYPE0 = 1, ++ TA_HDCP2_CONTENT_TYPE__TYPE1, ++}; ++ ++enum ta_hdcp_content_type_negotiation_type { ++ TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__FORCE_TYPE0 = 1, ++ TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__FORCE_TYPE1, ++ TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__MAX_SUPPORTED ++}; ++ ++enum ta_hdcp2_version { ++ TA_HDCP2_VERSION_UNKNOWN = 0, ++ TA_HDCP2_VERSION_2_0 = 20, ++ TA_HDCP2_VERSION_2_1 = 21, ++ TA_HDCP2_VERSION_2_2 = 22 ++}; + + /* input/output structures for HDCP commands */ + /**********************************************************/ +@@ -232,6 +337,84 @@ struct ta_hdcp_cmd_hdcp1_get_encryption_status_output { + uint32_t protection_level; + }; + ++struct ta_hdcp_cmd_hdcp2_create_session_input_v2 { ++ uint32_t display_handle; ++ enum ta_hdcp_content_type_negotiation_type negotiate_content_type; ++}; ++ ++struct ta_hdcp_cmd_hdcp2_create_session_output_v2 { ++ uint32_t session_handle; ++}; ++ ++struct ta_hdcp_cmd_hdcp2_destroy_session_input { ++ uint32_t session_handle; ++}; ++ ++struct ta_hdcp_cmd_hdcp2_authentication_message_v2 { ++ enum ta_hdcp2_msg_id msg_id; ++ uint32_t msg_size; ++}; ++ ++struct ta_hdcp_cmd_hdcp2_process_authentication_message_input_v2 { ++ struct ta_hdcp_cmd_hdcp2_authentication_message_v2 msg1_desc; ++ struct ta_hdcp_cmd_hdcp2_authentication_message_v2 msg2_desc; ++ struct ta_hdcp_cmd_hdcp2_authentication_message_v2 msg3_desc; ++ uint8_t receiver_message[TA_HDCP__HDCP2_RX_BUF_MAX_SIZE]; ++}; ++ ++struct ta_hdcp_cmd_hdcp2_process_authentication_message_output_v2 { ++ uint32_t hdcp_version; ++ uint32_t is_km_stored; ++ uint32_t is_locality_precompute_support; ++ uint32_t is_repeater; ++ enum ta_hdcp2_msg_authentication_status msg1_status; ++ enum ta_hdcp2_msg_authentication_status msg2_status; ++ enum ta_hdcp2_msg_authentication_status msg3_status; ++}; ++ ++struct ta_hdcp_cmd_hdcp2_prepare_authentication_message_input_v2 { ++ enum ta_hdcp2_msg_id msg1_id; ++ enum ta_hdcp2_msg_id msg2_id; ++}; ++ ++struct ta_hdcp_cmd_hdcp2_prepare_authentication_message_output_v2 { ++ enum ta_hdcp2_msg_authentication_status msg1_status; ++ enum ta_hdcp2_msg_authentication_status msg2_status; ++ struct ta_hdcp_cmd_hdcp2_authentication_message_v2 msg1_desc; ++ struct ta_hdcp_cmd_hdcp2_authentication_message_v2 msg2_desc; ++ uint8_t transmitter_message[TA_HDCP__HDCP2_TX_BUF_MAX_SIZE]; ++}; ++ ++struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 { ++ uint32_t session_handle; ++ struct ta_hdcp_cmd_hdcp2_process_authentication_message_input_v2 process; ++ struct ta_hdcp_cmd_hdcp2_prepare_authentication_message_input_v2 prepare; ++}; ++ ++struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 { ++ uint32_t authentication_status; ++ struct ta_hdcp_cmd_hdcp2_process_authentication_message_output_v2 process; ++ struct ta_hdcp_cmd_hdcp2_prepare_authentication_message_output_v2 prepare; ++}; ++ ++struct ta_hdcp_cmd_hdcp2_set_encryption_input { ++ uint32_t session_handle; ++}; ++ ++struct ta_hdcp_cmd_hdcp2_get_encryption_status_input { ++ uint32_t session_handle; ++}; ++ ++struct ta_hdcp_cmd_hdcp2_get_encryption_status_output { ++ enum ta_hdcp_content_type hdcp2_type; ++ uint32_t protection_level; ++}; ++ ++struct ta_hdcp_cmd_hdcp2_enable_dp_stream_encryption_input { ++ uint32_t session_handle; ++ uint32_t display_handle; ++}; ++ + /**********************************************************/ + /* Common input structure for HDCP callbacks */ + union ta_hdcp_cmd_input { +@@ -242,6 +425,13 @@ union ta_hdcp_cmd_input { + struct ta_hdcp_cmd_hdcp1_enable_encryption_input hdcp1_enable_encryption; + struct ta_hdcp_cmd_hdcp1_enable_dp_stream_encryption_input hdcp1_enable_dp_stream_encryption; + struct ta_hdcp_cmd_hdcp1_get_encryption_status_input hdcp1_get_encryption_status; ++ struct ta_hdcp_cmd_hdcp2_destroy_session_input hdcp2_destroy_session; ++ struct ta_hdcp_cmd_hdcp2_set_encryption_input hdcp2_set_encryption; ++ struct ta_hdcp_cmd_hdcp2_get_encryption_status_input hdcp2_get_encryption_status; ++ struct ta_hdcp_cmd_hdcp2_create_session_input_v2 hdcp2_create_session_v2; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 ++ hdcp2_prepare_process_authentication_message_v2; ++ struct ta_hdcp_cmd_hdcp2_enable_dp_stream_encryption_input hdcp2_enable_dp_stream_encryption; + }; + + /* Common output structure for HDCP callbacks */ +@@ -250,6 +440,10 @@ union ta_hdcp_cmd_output { + struct ta_hdcp_cmd_hdcp1_first_part_authentication_output hdcp1_first_part_authentication; + struct ta_hdcp_cmd_hdcp1_second_part_authentication_output hdcp1_second_part_authentication; + struct ta_hdcp_cmd_hdcp1_get_encryption_status_output hdcp1_get_encryption_status; ++ struct ta_hdcp_cmd_hdcp2_get_encryption_status_output hdcp2_get_encryption_status; ++ struct ta_hdcp_cmd_hdcp2_create_session_output_v2 hdcp2_create_session_v2; ++ struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 ++ hdcp2_prepare_process_authentication_message_v2; + }; + /**********************************************************/ + +-- +2.17.1 + |