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> Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
This commit is contained in:
Bhawanpreet Lakha
Alex Deucher
parent
f020220e16
commit
11a00965d2
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
};
|
||||
/**********************************************************/
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue