diff options
Diffstat (limited to 'meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.19.8/3861-drm-amd-display-add-PSP-block-to-verify-hdcp-steps.patch')
| -rw-r--r-- | meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.19.8/3861-drm-amd-display-add-PSP-block-to-verify-hdcp-steps.patch | 637 |
1 files changed, 637 insertions, 0 deletions
diff --git a/meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.19.8/3861-drm-amd-display-add-PSP-block-to-verify-hdcp-steps.patch b/meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.19.8/3861-drm-amd-display-add-PSP-block-to-verify-hdcp-steps.patch new file mode 100644 index 00000000..46318d55 --- /dev/null +++ b/meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.19.8/3861-drm-amd-display-add-PSP-block-to-verify-hdcp-steps.patch @@ -0,0 +1,637 @@ +From 0008c5471d74cc19c910a6341f3386fb25ca7a52 Mon Sep 17 00:00:00 2001 +From: Bhawanpreet Lakha <Bhawanpreet.Lakha@amd.com> +Date: Tue, 6 Aug 2019 18:04:44 -0400 +Subject: [PATCH 3861/4256] drm/amd/display: add PSP block to verify hdcp steps + +[Why] +All the HDCP transactions should be verified using PSP. + +[How] +This patch calls psp with the correct inputs to verify the steps +of authentication. + +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> +--- + .../drm/amd/display/modules/hdcp/hdcp_psp.c | 328 ++++++++++++++++++ + .../drm/amd/display/modules/hdcp/hdcp_psp.h | 272 +++++++++++++++ + 2 files changed, 600 insertions(+) + create mode 100644 drivers/gpu/drm/amd/display/modules/hdcp/hdcp_psp.c + create mode 100644 drivers/gpu/drm/amd/display/modules/hdcp/hdcp_psp.h + +diff --git a/drivers/gpu/drm/amd/display/modules/hdcp/hdcp_psp.c b/drivers/gpu/drm/amd/display/modules/hdcp/hdcp_psp.c +new file mode 100644 +index 000000000000..646d909bbc37 +--- /dev/null ++++ b/drivers/gpu/drm/amd/display/modules/hdcp/hdcp_psp.c +@@ -0,0 +1,328 @@ ++/* ++ * Copyright 2018 Advanced Micro Devices, Inc. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR ++ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ++ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ++ * OTHER DEALINGS IN THE SOFTWARE. ++ * ++ * Authors: AMD ++ * ++ */ ++ ++#define MAX_NUM_DISPLAYS 24 ++ ++ ++#include "hdcp.h" ++ ++#include "amdgpu.h" ++#include "hdcp_psp.h" ++ ++enum mod_hdcp_status mod_hdcp_remove_display_topology(struct mod_hdcp *hdcp) ++{ ++ ++ struct psp_context *psp = hdcp->config.psp.handle; ++ struct ta_dtm_shared_memory *dtm_cmd; ++ struct mod_hdcp_display *display = NULL; ++ uint8_t i; ++ ++ 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) { ++ ++ memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory)); ++ ++ display = &hdcp->connection.displays[i]; ++ ++ dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V2; ++ dtm_cmd->dtm_in_message.topology_update_v2.display_handle = display->index; ++ dtm_cmd->dtm_in_message.topology_update_v2.is_active = 0; ++ dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE; ++ ++ psp_dtm_invoke(psp, dtm_cmd->cmd_id); ++ ++ if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_UPDATE_TOPOLOGY_FAILURE; ++ ++ display->state = MOD_HDCP_DISPLAY_ACTIVE; ++ HDCP_TOP_REMOVE_DISPLAY_TRACE(hdcp, display->index); ++ } ++ } ++ ++ return MOD_HDCP_STATUS_SUCCESS; ++} ++ ++enum mod_hdcp_status mod_hdcp_add_display_topology(struct mod_hdcp *hdcp) ++{ ++ struct psp_context *psp = hdcp->config.psp.handle; ++ struct ta_dtm_shared_memory *dtm_cmd; ++ struct mod_hdcp_display *display = NULL; ++ struct mod_hdcp_link *link = &hdcp->connection.link; ++ uint8_t i; ++ ++ if (!psp->dtm_context.dtm_initialized) { ++ DRM_ERROR("Failed to add display topology, DTM TA is not initialized."); ++ return MOD_HDCP_STATUS_FAILURE; ++ } ++ ++ 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) { ++ display = &hdcp->connection.displays[i]; ++ ++ memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory)); ++ ++ dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V2; ++ dtm_cmd->dtm_in_message.topology_update_v2.display_handle = display->index; ++ dtm_cmd->dtm_in_message.topology_update_v2.is_active = 1; ++ dtm_cmd->dtm_in_message.topology_update_v2.controller = display->controller; ++ dtm_cmd->dtm_in_message.topology_update_v2.ddc_line = link->ddc_line; ++ dtm_cmd->dtm_in_message.topology_update_v2.dig_be = link->dig_be; ++ dtm_cmd->dtm_in_message.topology_update_v2.dig_fe = display->dig_fe; ++ dtm_cmd->dtm_in_message.topology_update_v2.dp_mst_vcid = display->vc_id; ++ dtm_cmd->dtm_in_message.topology_update_v2.max_hdcp_supported_version = ++ TA_DTM_HDCP_VERSION_MAX_SUPPORTED__1_x; ++ dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE; ++ ++ psp_dtm_invoke(psp, dtm_cmd->cmd_id); ++ ++ if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_UPDATE_TOPOLOGY_FAILURE; ++ ++ display->state = MOD_HDCP_DISPLAY_ACTIVE_AND_ADDED; ++ HDCP_TOP_ADD_DISPLAY_TRACE(hdcp, display->index); ++ } ++ } ++ ++ return MOD_HDCP_STATUS_SUCCESS; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp1_create_session(struct mod_hdcp *hdcp) ++{ ++ ++ struct psp_context *psp = hdcp->config.psp.handle; ++ struct mod_hdcp_display *display = get_first_added_display(hdcp); ++ struct ta_hdcp_shared_memory *hdcp_cmd; ++ ++ 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)); ++ ++ hdcp_cmd->in_msg.hdcp1_create_session.display_handle = display->index; ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_CREATE_SESSION; ++ ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP1_CREATE_SESSION_FAILURE; ++ ++ hdcp->auth.id = hdcp_cmd->out_msg.hdcp1_create_session.session_handle; ++ hdcp->auth.msg.hdcp1.ainfo = hdcp_cmd->out_msg.hdcp1_create_session.ainfo_primary; ++ memcpy(hdcp->auth.msg.hdcp1.aksv, hdcp_cmd->out_msg.hdcp1_create_session.aksv_primary, ++ sizeof(hdcp->auth.msg.hdcp1.aksv)); ++ memcpy(hdcp->auth.msg.hdcp1.an, hdcp_cmd->out_msg.hdcp1_create_session.an_primary, ++ sizeof(hdcp->auth.msg.hdcp1.an)); ++ ++ return MOD_HDCP_STATUS_SUCCESS; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp1_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.hdcp1_destroy_session.session_handle = hdcp->auth.id; ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_DESTROY_SESSION; ++ ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP1_DESTROY_SESSION_FAILURE; ++ ++ HDCP_TOP_HDCP1_DESTROY_SESSION_TRACE(hdcp); ++ ++ return MOD_HDCP_STATUS_SUCCESS; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp1_validate_rx(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.hdcp1_first_part_authentication.session_handle = hdcp->auth.id; ++ ++ memcpy(hdcp_cmd->in_msg.hdcp1_first_part_authentication.bksv_primary, hdcp->auth.msg.hdcp1.bksv, ++ TA_HDCP__HDCP1_KSV_SIZE); ++ ++ hdcp_cmd->in_msg.hdcp1_first_part_authentication.r0_prime_primary = hdcp->auth.msg.hdcp1.r0p; ++ hdcp_cmd->in_msg.hdcp1_first_part_authentication.bcaps = hdcp->auth.msg.hdcp1.bcaps; ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_FIRST_PART_AUTHENTICATION; ++ ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP1_VALIDATE_RX_FAILURE; ++ ++ if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status == ++ TA_HDCP_AUTHENTICATION_STATUS__HDCP1_FIRST_PART_COMPLETE) { ++ /* needs second part of authentication */ ++ hdcp->connection.is_repeater = 1; ++ } else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status == ++ TA_HDCP_AUTHENTICATION_STATUS__HDCP1_AUTHENTICATED) { ++ hdcp->connection.is_repeater = 0; ++ } else ++ return MOD_HDCP_STATUS_HDCP1_VALIDATE_RX_FAILURE; ++ ++ ++ return MOD_HDCP_STATUS_SUCCESS; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp1_enable_encryption(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); ++ ++ 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.hdcp1_enable_encryption.session_handle = hdcp->auth.id; ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_ENABLE_ENCRYPTION; ++ ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP1_ENABLE_ENCRYPTION; ++ ++ if (!is_dp_mst_hdcp(hdcp)) { ++ display->state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED; ++ HDCP_HDCP1_ENABLED_TRACE(hdcp, display->index); ++ } ++ return MOD_HDCP_STATUS_SUCCESS; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp1_validate_ksvlist_vp(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.hdcp1_second_part_authentication.session_handle = hdcp->auth.id; ++ ++ hdcp_cmd->in_msg.hdcp1_second_part_authentication.ksv_list_size = hdcp->auth.msg.hdcp1.ksvlist_size; ++ memcpy(hdcp_cmd->in_msg.hdcp1_second_part_authentication.ksv_list, hdcp->auth.msg.hdcp1.ksvlist, ++ hdcp->auth.msg.hdcp1.ksvlist_size); ++ ++ memcpy(hdcp_cmd->in_msg.hdcp1_second_part_authentication.v_prime, hdcp->auth.msg.hdcp1.vp, ++ sizeof(hdcp->auth.msg.hdcp1.vp)); ++ ++ hdcp_cmd->in_msg.hdcp1_second_part_authentication.bstatus_binfo = ++ is_dp_hdcp(hdcp) ? hdcp->auth.msg.hdcp1.binfo_dp : hdcp->auth.msg.hdcp1.bstatus; ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_SECOND_PART_AUTHENTICATION; ++ ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP1_VALIDATE_KSV_LIST_FAILURE; ++ ++ return MOD_HDCP_STATUS_SUCCESS; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp1_enable_dp_stream_encryption(struct mod_hdcp *hdcp) ++{ ++ ++ struct psp_context *psp = hdcp->config.psp.handle; ++ struct ta_hdcp_shared_memory *hdcp_cmd; ++ int i = 0; ++ ++ hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; ++ ++ 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; ++ ++ memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); ++ ++ hdcp_cmd->in_msg.hdcp1_enable_dp_stream_encryption.session_handle = hdcp->auth.id; ++ hdcp_cmd->in_msg.hdcp1_enable_dp_stream_encryption.display_handle = hdcp->connection.displays[i].index; ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_ENABLE_DP_STREAM_ENCRYPTION; ++ ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP1_ENABLE_STREAM_ENCRYPTION_FAILURE; ++ ++ hdcp->connection.displays[i].state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED; ++ HDCP_HDCP1_ENABLED_TRACE(hdcp, hdcp->connection.displays[i].index); ++ } ++ ++ return MOD_HDCP_STATUS_SUCCESS; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp1_link_maintenance(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.hdcp1_get_encryption_status.session_handle = hdcp->auth.id; ++ ++ hdcp_cmd->out_msg.hdcp1_get_encryption_status.protection_level = 0; ++ hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_GET_ENCRYPTION_STATUS; ++ ++ psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); ++ ++ if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) ++ return MOD_HDCP_STATUS_HDCP1_LINK_MAINTENANCE_FAILURE; ++ ++ return (hdcp_cmd->out_msg.hdcp1_get_encryption_status.protection_level == 1) ++ ? MOD_HDCP_STATUS_SUCCESS ++ : MOD_HDCP_STATUS_HDCP1_LINK_MAINTENANCE_FAILURE; ++} ++ ++enum mod_hdcp_status mod_hdcp_hdcp1_get_link_encryption_status(struct mod_hdcp *hdcp, ++ enum mod_hdcp_encryption_status *encryption_status) ++{ ++ *encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF; ++ ++ if (mod_hdcp_hdcp1_link_maintenance(hdcp) != MOD_HDCP_STATUS_SUCCESS) ++ return MOD_HDCP_STATUS_FAILURE; ++ ++ *encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP1_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 +new file mode 100644 +index 000000000000..986fc07ea9ea +--- /dev/null ++++ b/drivers/gpu/drm/amd/display/modules/hdcp/hdcp_psp.h +@@ -0,0 +1,272 @@ ++/* ++ * Copyright 2019 Advanced Micro Devices, Inc. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the "Software"), ++ * to deal in the Software without restriction, including without limitation ++ * the rights to use, copy, modify, merge, publish, distribute, sublicense, ++ * and/or sell copies of the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the following conditions: ++ * ++ * The above copyright notice and this permission notice shall be included in ++ * all copies or substantial portions of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ++ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR ++ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ++ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ++ * OTHER DEALINGS IN THE SOFTWARE. ++ * ++ * Authors: AMD ++ * ++ */ ++ ++#ifndef MODULES_HDCP_HDCP_PSP_H_ ++#define MODULES_HDCP_HDCP_PSP_H_ ++ ++/* ++ * NOTE: These parameters are a one-to-one copy of the ++ * parameters required by PSP ++ */ ++enum bgd_security_hdcp_encryption_level { ++ HDCP_ENCRYPTION_LEVEL__INVALID = 0, ++ HDCP_ENCRYPTION_LEVEL__OFF, ++ HDCP_ENCRYPTION_LEVEL__ON ++}; ++ ++enum ta_dtm_command { ++ TA_DTM_COMMAND__UNUSED_1 = 1, ++ TA_DTM_COMMAND__TOPOLOGY_UPDATE_V2, ++ TA_DTM_COMMAND__TOPOLOGY_ASSR_ENABLE ++}; ++ ++/* DTM related enumerations */ ++/**********************************************************/ ++ ++enum ta_dtm_status { ++ TA_DTM_STATUS__SUCCESS = 0x00, ++ TA_DTM_STATUS__GENERIC_FAILURE = 0x01, ++ TA_DTM_STATUS__INVALID_PARAMETER = 0x02, ++ TA_DTM_STATUS__NULL_POINTER = 0x3 ++}; ++ ++/* input/output structures for DTM commands */ ++/**********************************************************/ ++/** ++ * Input structures ++ */ ++enum ta_dtm_hdcp_version_max_supported { ++ TA_DTM_HDCP_VERSION_MAX_SUPPORTED__NONE = 0, ++ TA_DTM_HDCP_VERSION_MAX_SUPPORTED__1_x = 10, ++ TA_DTM_HDCP_VERSION_MAX_SUPPORTED__2_0 = 20, ++ TA_DTM_HDCP_VERSION_MAX_SUPPORTED__2_1 = 21, ++ TA_DTM_HDCP_VERSION_MAX_SUPPORTED__2_2 = 22, ++ TA_DTM_HDCP_VERSION_MAX_SUPPORTED__2_3 = 23 ++}; ++ ++struct ta_dtm_topology_update_input_v2 { ++ /* display handle is unique across the driver and is used to identify a display */ ++ /* for all security interfaces which reference displays such as HDCP */ ++ uint32_t display_handle; ++ uint32_t is_active; ++ uint32_t is_miracast; ++ uint32_t controller; ++ uint32_t ddc_line; ++ uint32_t dig_be; ++ uint32_t dig_fe; ++ uint32_t dp_mst_vcid; ++ uint32_t is_assr; ++ uint32_t max_hdcp_supported_version; ++}; ++ ++struct ta_dtm_topology_assr_enable { ++ uint32_t display_topology_dig_be_index; ++}; ++ ++/** ++ * Output structures ++ */ ++ ++/* No output structures yet */ ++ ++union ta_dtm_cmd_input { ++ struct ta_dtm_topology_update_input_v2 topology_update_v2; ++ struct ta_dtm_topology_assr_enable topology_assr_enable; ++}; ++ ++union ta_dtm_cmd_output { ++ uint32_t reserved; ++}; ++ ++struct ta_dtm_shared_memory { ++ uint32_t cmd_id; ++ uint32_t resp_id; ++ enum ta_dtm_status dtm_status; ++ uint32_t reserved; ++ union ta_dtm_cmd_input dtm_in_message; ++ union ta_dtm_cmd_output dtm_out_message; ++}; ++ ++int psp_cmd_submit_buf(struct psp_context *psp, struct amdgpu_firmware_info *ucode, struct psp_gfx_cmd_resp *cmd, ++ uint64_t fence_mc_addr); ++ ++enum ta_hdcp_command { ++ TA_HDCP_COMMAND__INITIALIZE, ++ TA_HDCP_COMMAND__HDCP1_CREATE_SESSION, ++ TA_HDCP_COMMAND__HDCP1_DESTROY_SESSION, ++ TA_HDCP_COMMAND__HDCP1_FIRST_PART_AUTHENTICATION, ++ TA_HDCP_COMMAND__HDCP1_SECOND_PART_AUTHENTICATION, ++ TA_HDCP_COMMAND__HDCP1_ENABLE_ENCRYPTION, ++ TA_HDCP_COMMAND__HDCP1_ENABLE_DP_STREAM_ENCRYPTION, ++ TA_HDCP_COMMAND__HDCP1_GET_ENCRYPTION_STATUS, ++}; ++ ++ ++/* HDCP related enumerations */ ++/**********************************************************/ ++#define TA_HDCP__INVALID_SESSION 0xFFFF ++#define TA_HDCP__HDCP1_AN_SIZE 8 ++#define TA_HDCP__HDCP1_KSV_SIZE 5 ++#define TA_HDCP__HDCP1_KSV_LIST_MAX_ENTRIES 127 ++#define TA_HDCP__HDCP1_V_PRIME_SIZE 20 ++ ++enum ta_hdcp_status { ++ TA_HDCP_STATUS__SUCCESS = 0x00, ++ TA_HDCP_STATUS__GENERIC_FAILURE = 0x01, ++ TA_HDCP_STATUS__NULL_POINTER = 0x02, ++ TA_HDCP_STATUS__FAILED_ALLOCATING_SESSION = 0x03, ++ TA_HDCP_STATUS__FAILED_SETUP_TX = 0x04, ++ TA_HDCP_STATUS__INVALID_PARAMETER = 0x05, ++ TA_HDCP_STATUS__VHX_ERROR = 0x06, ++ TA_HDCP_STATUS__SESSION_NOT_CLOSED_PROPERLY = 0x07, ++ TA_HDCP_STATUS__SRM_FAILURE = 0x08, ++ TA_HDCP_STATUS__MST_AUTHENTICATED_ALREADY_STARTED = 0x09, ++ TA_HDCP_STATUS__AKE_SEND_CERT_FAILURE = 0x0A, ++ TA_HDCP_STATUS__AKE_NO_STORED_KM_FAILURE = 0x0B, ++ TA_HDCP_STATUS__AKE_SEND_HPRIME_FAILURE = 0x0C, ++ TA_HDCP_STATUS__LC_SEND_LPRIME_FAILURE = 0x0D, ++ TA_HDCP_STATUS__SKE_SEND_EKS_FAILURE = 0x0E, ++ TA_HDCP_STATUS__REPAUTH_SEND_RXIDLIST_FAILURE = 0x0F, ++ TA_HDCP_STATUS__REPAUTH_STREAM_READY_FAILURE = 0x10, ++ TA_HDCP_STATUS__ASD_GENERIC_FAILURE = 0x11, ++ TA_HDCP_STATUS__UNWRAP_SECRET_FAILURE = 0x12, ++ TA_HDCP_STATUS__ENABLE_ENCR_FAILURE = 0x13, ++ TA_HDCP_STATUS__DISABLE_ENCR_FAILURE = 0x14, ++ TA_HDCP_STATUS__NOT_ENOUGH_MEMORY_FAILURE = 0x15, ++ TA_HDCP_STATUS__UNKNOWN_MESSAGE = 0x16, ++ TA_HDCP_STATUS__TOO_MANY_STREAM = 0x17 ++}; ++ ++enum ta_hdcp_authentication_status { ++ TA_HDCP_AUTHENTICATION_STATUS__NOT_STARTED = 0x00, ++ TA_HDCP_AUTHENTICATION_STATUS__HDCP1_FIRST_PART_FAILED = 0x01, ++ 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__HDCP1_KSV_VALIDATION_FAILED = 0x09 ++}; ++ ++ ++/* input/output structures for HDCP commands */ ++/**********************************************************/ ++struct ta_hdcp_cmd_hdcp1_create_session_input { ++ uint8_t display_handle; ++}; ++ ++struct ta_hdcp_cmd_hdcp1_create_session_output { ++ uint32_t session_handle; ++ uint8_t an_primary[TA_HDCP__HDCP1_AN_SIZE]; ++ uint8_t aksv_primary[TA_HDCP__HDCP1_KSV_SIZE]; ++ uint8_t ainfo_primary; ++ uint8_t an_secondary[TA_HDCP__HDCP1_AN_SIZE]; ++ uint8_t aksv_secondary[TA_HDCP__HDCP1_KSV_SIZE]; ++ uint8_t ainfo_secondary; ++}; ++ ++struct ta_hdcp_cmd_hdcp1_destroy_session_input { ++ uint32_t session_handle; ++}; ++ ++struct ta_hdcp_cmd_hdcp1_first_part_authentication_input { ++ uint32_t session_handle; ++ uint8_t bksv_primary[TA_HDCP__HDCP1_KSV_SIZE]; ++ uint8_t bksv_secondary[TA_HDCP__HDCP1_KSV_SIZE]; ++ uint8_t bcaps; ++ uint16_t r0_prime_primary; ++ uint16_t r0_prime_secondary; ++}; ++ ++struct ta_hdcp_cmd_hdcp1_first_part_authentication_output { ++ enum ta_hdcp_authentication_status authentication_status; ++}; ++ ++struct ta_hdcp_cmd_hdcp1_second_part_authentication_input { ++ uint32_t session_handle; ++ uint16_t bstatus_binfo; ++ uint8_t ksv_list[TA_HDCP__HDCP1_KSV_LIST_MAX_ENTRIES][TA_HDCP__HDCP1_KSV_SIZE]; ++ uint32_t ksv_list_size; ++ uint8_t pj_prime; ++ uint8_t v_prime[TA_HDCP__HDCP1_V_PRIME_SIZE]; ++}; ++ ++struct ta_hdcp_cmd_hdcp1_second_part_authentication_output { ++ enum ta_hdcp_authentication_status authentication_status; ++}; ++ ++struct ta_hdcp_cmd_hdcp1_enable_encryption_input { ++ uint32_t session_handle; ++}; ++ ++struct ta_hdcp_cmd_hdcp1_enable_dp_stream_encryption_input { ++ uint32_t session_handle; ++ uint32_t display_handle; ++}; ++ ++struct ta_hdcp_cmd_hdcp1_get_encryption_status_input { ++ uint32_t session_handle; ++}; ++ ++struct ta_hdcp_cmd_hdcp1_get_encryption_status_output { ++ uint32_t protection_level; ++}; ++ ++/**********************************************************/ ++/* Common input structure for HDCP callbacks */ ++union ta_hdcp_cmd_input { ++ struct ta_hdcp_cmd_hdcp1_create_session_input hdcp1_create_session; ++ struct ta_hdcp_cmd_hdcp1_destroy_session_input hdcp1_destroy_session; ++ struct ta_hdcp_cmd_hdcp1_first_part_authentication_input hdcp1_first_part_authentication; ++ struct ta_hdcp_cmd_hdcp1_second_part_authentication_input hdcp1_second_part_authentication; ++ 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; ++}; ++ ++/* Common output structure for HDCP callbacks */ ++union ta_hdcp_cmd_output { ++ struct ta_hdcp_cmd_hdcp1_create_session_output hdcp1_create_session; ++ 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_shared_memory { ++ uint32_t cmd_id; ++ enum ta_hdcp_status hdcp_status; ++ uint32_t reserved; ++ union ta_hdcp_cmd_input in_msg; ++ union ta_hdcp_cmd_output out_msg; ++}; ++ ++enum psp_status { ++ PSP_STATUS__SUCCESS = 0, ++ PSP_STATUS__ERROR_INVALID_PARAMS, ++ PSP_STATUS__ERROR_GENERIC, ++ PSP_STATUS__ERROR_OUT_OF_MEMORY, ++ PSP_STATUS__ERROR_UNSUPPORTED_FEATURE ++}; ++ ++#endif /* MODULES_HDCP_HDCP_PSP_H_ */ +-- +2.17.1 + |