Back to home page

OSCL-LXR
 
 

     

0001 /*
0002  * Copyright 2018 Advanced Micro Devices, Inc.
0003  *
0004  * Permission is hereby granted, free of charge, to any person obtaining a
0005  * copy of this software and associated documentation files (the "Software"),
0006  * to deal in the Software without restriction, including without limitation
0007  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
0008  * and/or sell copies of the Software, and to permit persons to whom the
0009  * Software is furnished to do so, subject to the following conditions:
0010  *
0011  * The above copyright notice and this permission notice shall be included in
0012  * all copies or substantial portions of the Software.
0013  *
0014  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
0015  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
0016  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
0017  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
0018  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
0019  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
0020  * OTHER DEALINGS IN THE SOFTWARE.
0021  *
0022  * Authors: AMD
0023  *
0024  */
0025 
0026 #define MAX_NUM_DISPLAYS 24
0027 
0028 
0029 #include "hdcp.h"
0030 
0031 #include "amdgpu.h"
0032 #include "hdcp_psp.h"
0033 
0034 static void hdcp2_message_init(struct mod_hdcp *hdcp,
0035                    struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *in)
0036 {
0037     in->session_handle = hdcp->auth.id;
0038     in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE;
0039     in->prepare.msg2_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE;
0040     in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE;
0041     in->process.msg1_desc.msg_size = 0;
0042     in->process.msg2_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE;
0043     in->process.msg2_desc.msg_size = 0;
0044     in->process.msg3_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE;
0045     in->process.msg3_desc.msg_size = 0;
0046 }
0047 
0048 static enum mod_hdcp_status remove_display_from_topology_v2(
0049         struct mod_hdcp *hdcp, uint8_t index)
0050 {
0051     struct psp_context *psp = hdcp->config.psp.handle;
0052     struct ta_dtm_shared_memory *dtm_cmd;
0053     struct mod_hdcp_display *display =
0054             get_active_display_at_index(hdcp, index);
0055     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0056 
0057     dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.context.mem_context.shared_buf;
0058 
0059     if (!display || !is_display_active(display))
0060         return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
0061 
0062     mutex_lock(&psp->dtm_context.mutex);
0063 
0064     memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory));
0065 
0066     dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V2;
0067     dtm_cmd->dtm_in_message.topology_update_v2.display_handle = display->index;
0068     dtm_cmd->dtm_in_message.topology_update_v2.is_active = 0;
0069     dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE;
0070 
0071     psp_dtm_invoke(psp, dtm_cmd->cmd_id);
0072 
0073     if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) {
0074         status = MOD_HDCP_STATUS_UPDATE_TOPOLOGY_FAILURE;
0075     } else {
0076         display->state = MOD_HDCP_DISPLAY_ACTIVE;
0077         HDCP_TOP_REMOVE_DISPLAY_TRACE(hdcp, display->index);
0078     }
0079 
0080     mutex_unlock(&psp->dtm_context.mutex);
0081     return status;
0082 }
0083 
0084 static enum mod_hdcp_status remove_display_from_topology_v3(
0085         struct mod_hdcp *hdcp, uint8_t index)
0086 {
0087     struct psp_context *psp = hdcp->config.psp.handle;
0088     struct ta_dtm_shared_memory *dtm_cmd;
0089     struct mod_hdcp_display *display =
0090         get_active_display_at_index(hdcp, index);
0091     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0092 
0093     dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.context.mem_context.shared_buf;
0094 
0095     if (!display || !is_display_active(display))
0096         return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
0097 
0098     mutex_lock(&psp->dtm_context.mutex);
0099 
0100     memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory));
0101 
0102     dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V3;
0103     dtm_cmd->dtm_in_message.topology_update_v3.display_handle = display->index;
0104     dtm_cmd->dtm_in_message.topology_update_v3.is_active = 0;
0105     dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE;
0106 
0107     psp_dtm_invoke(psp, dtm_cmd->cmd_id);
0108     mutex_unlock(&psp->dtm_context.mutex);
0109 
0110     if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) {
0111         status = remove_display_from_topology_v2(hdcp, index);
0112         if (status != MOD_HDCP_STATUS_SUCCESS)
0113             display->state = MOD_HDCP_DISPLAY_INACTIVE;
0114     } else {
0115         display->state = MOD_HDCP_DISPLAY_ACTIVE;
0116         HDCP_TOP_REMOVE_DISPLAY_TRACE(hdcp, display->index);
0117     }
0118 
0119     return status;
0120 }
0121 
0122 static enum mod_hdcp_status add_display_to_topology_v2(
0123         struct mod_hdcp *hdcp, struct mod_hdcp_display *display)
0124 {
0125     struct psp_context *psp = hdcp->config.psp.handle;
0126     struct ta_dtm_shared_memory *dtm_cmd;
0127     struct mod_hdcp_link *link = &hdcp->connection.link;
0128     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0129 
0130     if (!psp->dtm_context.context.initialized) {
0131         DRM_INFO("Failed to add display topology, DTM TA is not initialized.");
0132         display->state = MOD_HDCP_DISPLAY_INACTIVE;
0133         return MOD_HDCP_STATUS_FAILURE;
0134     }
0135 
0136     dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.context.mem_context.shared_buf;
0137 
0138     mutex_lock(&psp->dtm_context.mutex);
0139     memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory));
0140 
0141     dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V2;
0142     dtm_cmd->dtm_in_message.topology_update_v2.display_handle = display->index;
0143     dtm_cmd->dtm_in_message.topology_update_v2.is_active = 1;
0144     dtm_cmd->dtm_in_message.topology_update_v2.controller = display->controller;
0145     dtm_cmd->dtm_in_message.topology_update_v2.ddc_line = link->ddc_line;
0146     dtm_cmd->dtm_in_message.topology_update_v2.dig_be = link->dig_be;
0147     dtm_cmd->dtm_in_message.topology_update_v2.dig_fe = display->dig_fe;
0148     if (is_dp_hdcp(hdcp))
0149         dtm_cmd->dtm_in_message.topology_update_v2.is_assr = link->dp.assr_enabled;
0150 
0151     dtm_cmd->dtm_in_message.topology_update_v2.dp_mst_vcid = display->vc_id;
0152     dtm_cmd->dtm_in_message.topology_update_v2.max_hdcp_supported_version =
0153             TA_DTM_HDCP_VERSION_MAX_SUPPORTED__2_2;
0154     dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE;
0155 
0156     psp_dtm_invoke(psp, dtm_cmd->cmd_id);
0157 
0158     if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) {
0159         display->state = MOD_HDCP_DISPLAY_INACTIVE;
0160         status = MOD_HDCP_STATUS_UPDATE_TOPOLOGY_FAILURE;
0161     } else {
0162         HDCP_TOP_ADD_DISPLAY_TRACE(hdcp, display->index);
0163     }
0164 
0165     mutex_unlock(&psp->dtm_context.mutex);
0166     return status;
0167 }
0168 
0169 static enum mod_hdcp_status add_display_to_topology_v3(
0170         struct mod_hdcp *hdcp, struct mod_hdcp_display *display)
0171 {
0172     struct psp_context *psp = hdcp->config.psp.handle;
0173     struct ta_dtm_shared_memory *dtm_cmd;
0174     struct mod_hdcp_link *link = &hdcp->connection.link;
0175     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0176 
0177     if (!psp->dtm_context.context.initialized) {
0178         DRM_INFO("Failed to add display topology, DTM TA is not initialized.");
0179         display->state = MOD_HDCP_DISPLAY_INACTIVE;
0180         return MOD_HDCP_STATUS_FAILURE;
0181     }
0182 
0183     dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.context.mem_context.shared_buf;
0184 
0185     mutex_lock(&psp->dtm_context.mutex);
0186     memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory));
0187 
0188     dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V3;
0189     dtm_cmd->dtm_in_message.topology_update_v3.display_handle = display->index;
0190     dtm_cmd->dtm_in_message.topology_update_v3.is_active = 1;
0191     dtm_cmd->dtm_in_message.topology_update_v3.controller = display->controller;
0192     dtm_cmd->dtm_in_message.topology_update_v3.ddc_line = link->ddc_line;
0193     dtm_cmd->dtm_in_message.topology_update_v3.link_enc = link->link_enc_idx;
0194     dtm_cmd->dtm_in_message.topology_update_v3.stream_enc = display->stream_enc_idx;
0195     if (is_dp_hdcp(hdcp))
0196         dtm_cmd->dtm_in_message.topology_update_v3.is_assr = link->dp.assr_enabled;
0197 
0198     dtm_cmd->dtm_in_message.topology_update_v3.dp_mst_vcid = display->vc_id;
0199     dtm_cmd->dtm_in_message.topology_update_v3.max_hdcp_supported_version =
0200             TA_DTM_HDCP_VERSION_MAX_SUPPORTED__2_3;
0201     dtm_cmd->dtm_in_message.topology_update_v3.encoder_type = TA_DTM_ENCODER_TYPE__DIG;
0202     dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE;
0203     dtm_cmd->dtm_in_message.topology_update_v3.phy_id = link->phy_idx;
0204     dtm_cmd->dtm_in_message.topology_update_v3.link_hdcp_cap = link->hdcp_supported_informational;
0205     dtm_cmd->dtm_in_message.topology_update_v3.dio_output_type = link->dp.usb4_enabled ?
0206             TA_DTM_DIO_OUTPUT_TYPE__DPIA :
0207             TA_DTM_DIO_OUTPUT_TYPE__DIRECT;
0208     dtm_cmd->dtm_in_message.topology_update_v3.dio_output_id = link->dio_output_id;
0209 
0210     psp_dtm_invoke(psp, dtm_cmd->cmd_id);
0211     mutex_unlock(&psp->dtm_context.mutex);
0212 
0213     if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) {
0214         status = add_display_to_topology_v2(hdcp, display);
0215         if (status != MOD_HDCP_STATUS_SUCCESS)
0216             display->state = MOD_HDCP_DISPLAY_INACTIVE;
0217     } else {
0218         HDCP_TOP_ADD_DISPLAY_TRACE(hdcp, display->index);
0219     }
0220 
0221     return status;
0222 }
0223 
0224 enum mod_hdcp_status mod_hdcp_remove_display_from_topology(
0225         struct mod_hdcp *hdcp, uint8_t index)
0226 {
0227     enum mod_hdcp_status status = MOD_HDCP_STATUS_UPDATE_TOPOLOGY_FAILURE;
0228 
0229     if (hdcp->config.psp.caps.dtm_v3_supported)
0230         status = remove_display_from_topology_v3(hdcp, index);
0231     else
0232         status = remove_display_from_topology_v2(hdcp, index);
0233 
0234     return status;
0235 }
0236 
0237 enum mod_hdcp_status mod_hdcp_add_display_to_topology(struct mod_hdcp *hdcp,
0238                            struct mod_hdcp_display *display)
0239 {
0240     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0241 
0242     if (hdcp->config.psp.caps.dtm_v3_supported)
0243         status = add_display_to_topology_v3(hdcp, display);
0244     else
0245         status = add_display_to_topology_v2(hdcp, display);
0246 
0247     return status;
0248 }
0249 
0250 enum mod_hdcp_status mod_hdcp_hdcp1_create_session(struct mod_hdcp *hdcp)
0251 {
0252 
0253     struct psp_context *psp = hdcp->config.psp.handle;
0254     struct mod_hdcp_display *display = get_first_active_display(hdcp);
0255     struct ta_hdcp_shared_memory *hdcp_cmd;
0256     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0257 
0258     if (!psp->hdcp_context.context.initialized) {
0259         DRM_ERROR("Failed to create hdcp session. HDCP TA is not initialized.");
0260         return MOD_HDCP_STATUS_FAILURE;
0261     }
0262 
0263     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
0264 
0265     mutex_lock(&psp->hdcp_context.mutex);
0266     memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
0267 
0268     hdcp_cmd->in_msg.hdcp1_create_session.display_handle = display->index;
0269     hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_CREATE_SESSION;
0270 
0271     psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
0272 
0273     hdcp->auth.id = hdcp_cmd->out_msg.hdcp1_create_session.session_handle;
0274 
0275     if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
0276         status = MOD_HDCP_STATUS_HDCP1_CREATE_SESSION_FAILURE;
0277     } else {
0278         hdcp->auth.msg.hdcp1.ainfo = hdcp_cmd->out_msg.hdcp1_create_session.ainfo_primary;
0279         memcpy(hdcp->auth.msg.hdcp1.aksv, hdcp_cmd->out_msg.hdcp1_create_session.aksv_primary,
0280                sizeof(hdcp->auth.msg.hdcp1.aksv));
0281         memcpy(hdcp->auth.msg.hdcp1.an, hdcp_cmd->out_msg.hdcp1_create_session.an_primary,
0282                sizeof(hdcp->auth.msg.hdcp1.an));
0283     }
0284 
0285     mutex_unlock(&psp->hdcp_context.mutex);
0286     return status;
0287 }
0288 
0289 enum mod_hdcp_status mod_hdcp_hdcp1_destroy_session(struct mod_hdcp *hdcp)
0290 {
0291 
0292     struct psp_context *psp = hdcp->config.psp.handle;
0293     struct ta_hdcp_shared_memory *hdcp_cmd;
0294     uint8_t i = 0;
0295     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0296 
0297     mutex_lock(&psp->hdcp_context.mutex);
0298     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
0299     memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
0300 
0301     hdcp_cmd->in_msg.hdcp1_destroy_session.session_handle = hdcp->auth.id;
0302     hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_DESTROY_SESSION;
0303 
0304     psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
0305 
0306     if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
0307         status = MOD_HDCP_STATUS_HDCP1_DESTROY_SESSION_FAILURE;
0308     } else {
0309         HDCP_TOP_HDCP1_DESTROY_SESSION_TRACE(hdcp);
0310         for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++)
0311             if (is_display_encryption_enabled(&hdcp->displays[i])) {
0312                 hdcp->displays[i].state =
0313                             MOD_HDCP_DISPLAY_ACTIVE;
0314                 HDCP_HDCP1_DISABLED_TRACE(
0315                     hdcp, hdcp->displays[i].index);
0316             }
0317     }
0318 
0319     mutex_unlock(&psp->hdcp_context.mutex);
0320     return status;
0321 }
0322 
0323 enum mod_hdcp_status mod_hdcp_hdcp1_validate_rx(struct mod_hdcp *hdcp)
0324 {
0325     struct psp_context *psp = hdcp->config.psp.handle;
0326     struct ta_hdcp_shared_memory *hdcp_cmd;
0327     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0328 
0329     mutex_lock(&psp->hdcp_context.mutex);
0330     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
0331     memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
0332 
0333     hdcp_cmd->in_msg.hdcp1_first_part_authentication.session_handle = hdcp->auth.id;
0334 
0335     memcpy(hdcp_cmd->in_msg.hdcp1_first_part_authentication.bksv_primary, hdcp->auth.msg.hdcp1.bksv,
0336         TA_HDCP__HDCP1_KSV_SIZE);
0337 
0338     hdcp_cmd->in_msg.hdcp1_first_part_authentication.r0_prime_primary = hdcp->auth.msg.hdcp1.r0p;
0339     hdcp_cmd->in_msg.hdcp1_first_part_authentication.bcaps = hdcp->auth.msg.hdcp1.bcaps;
0340     hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_FIRST_PART_AUTHENTICATION;
0341 
0342     psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
0343 
0344     if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
0345         status = MOD_HDCP_STATUS_HDCP1_VALIDATE_RX_FAILURE;
0346     } else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status ==
0347         TA_HDCP_AUTHENTICATION_STATUS__HDCP1_FIRST_PART_COMPLETE) {
0348         /* needs second part of authentication */
0349         hdcp->connection.is_repeater = 1;
0350     } else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status ==
0351            TA_HDCP_AUTHENTICATION_STATUS__HDCP1_AUTHENTICATED) {
0352         hdcp->connection.is_repeater = 0;
0353     } else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status ==
0354            TA_HDCP_AUTHENTICATION_STATUS__HDCP1_KSV_REVOKED) {
0355         hdcp->connection.is_hdcp1_revoked = 1;
0356         status = MOD_HDCP_STATUS_HDCP1_BKSV_REVOKED;
0357     } else
0358         status = MOD_HDCP_STATUS_HDCP1_VALIDATE_RX_FAILURE;
0359 
0360     mutex_unlock(&psp->hdcp_context.mutex);
0361     return status;
0362 }
0363 
0364 enum mod_hdcp_status mod_hdcp_hdcp1_enable_encryption(struct mod_hdcp *hdcp)
0365 {
0366     struct psp_context *psp = hdcp->config.psp.handle;
0367     struct ta_hdcp_shared_memory *hdcp_cmd;
0368     struct mod_hdcp_display *display = get_first_active_display(hdcp);
0369     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0370 
0371     mutex_lock(&psp->hdcp_context.mutex);
0372     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
0373     memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
0374 
0375     hdcp_cmd->in_msg.hdcp1_enable_encryption.session_handle = hdcp->auth.id;
0376     hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_ENABLE_ENCRYPTION;
0377 
0378     psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
0379 
0380     if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
0381         status = MOD_HDCP_STATUS_HDCP1_ENABLE_ENCRYPTION_FAILURE;
0382     } else if (!is_dp_mst_hdcp(hdcp)) {
0383         display->state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;
0384         HDCP_HDCP1_ENABLED_TRACE(hdcp, display->index);
0385     }
0386 
0387     mutex_unlock(&psp->hdcp_context.mutex);
0388     return status;
0389 }
0390 
0391 enum mod_hdcp_status mod_hdcp_hdcp1_validate_ksvlist_vp(struct mod_hdcp *hdcp)
0392 {
0393     struct psp_context *psp = hdcp->config.psp.handle;
0394     struct ta_hdcp_shared_memory *hdcp_cmd;
0395     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0396 
0397     mutex_lock(&psp->hdcp_context.mutex);
0398     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
0399     memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
0400 
0401     hdcp_cmd->in_msg.hdcp1_second_part_authentication.session_handle = hdcp->auth.id;
0402 
0403     hdcp_cmd->in_msg.hdcp1_second_part_authentication.ksv_list_size = hdcp->auth.msg.hdcp1.ksvlist_size;
0404     memcpy(hdcp_cmd->in_msg.hdcp1_second_part_authentication.ksv_list, hdcp->auth.msg.hdcp1.ksvlist,
0405            hdcp->auth.msg.hdcp1.ksvlist_size);
0406 
0407     memcpy(hdcp_cmd->in_msg.hdcp1_second_part_authentication.v_prime, hdcp->auth.msg.hdcp1.vp,
0408            sizeof(hdcp->auth.msg.hdcp1.vp));
0409 
0410     hdcp_cmd->in_msg.hdcp1_second_part_authentication.bstatus_binfo =
0411         is_dp_hdcp(hdcp) ? hdcp->auth.msg.hdcp1.binfo_dp : hdcp->auth.msg.hdcp1.bstatus;
0412     hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_SECOND_PART_AUTHENTICATION;
0413 
0414     psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
0415 
0416     if (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS &&
0417         hdcp_cmd->out_msg.hdcp1_second_part_authentication.authentication_status ==
0418             TA_HDCP_AUTHENTICATION_STATUS__HDCP1_AUTHENTICATED) {
0419         status = MOD_HDCP_STATUS_SUCCESS;
0420     } else if (hdcp_cmd->out_msg.hdcp1_second_part_authentication.authentication_status ==
0421            TA_HDCP_AUTHENTICATION_STATUS__HDCP1_KSV_REVOKED) {
0422         hdcp->connection.is_hdcp1_revoked = 1;
0423         status = MOD_HDCP_STATUS_HDCP1_KSV_LIST_REVOKED;
0424     } else {
0425         status = MOD_HDCP_STATUS_HDCP1_VALIDATE_KSV_LIST_FAILURE;
0426     }
0427 
0428     mutex_unlock(&psp->hdcp_context.mutex);
0429     return status;
0430 }
0431 
0432 enum mod_hdcp_status mod_hdcp_hdcp1_enable_dp_stream_encryption(struct mod_hdcp *hdcp)
0433 {
0434 
0435     struct psp_context *psp = hdcp->config.psp.handle;
0436     struct ta_hdcp_shared_memory *hdcp_cmd;
0437     int i = 0;
0438     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0439 
0440     mutex_lock(&psp->hdcp_context.mutex);
0441     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
0442 
0443     for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) {
0444 
0445         if (hdcp->displays[i].adjust.disable || hdcp->displays[i].state != MOD_HDCP_DISPLAY_ACTIVE)
0446                 continue;
0447 
0448         memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
0449 
0450         hdcp_cmd->in_msg.hdcp1_enable_dp_stream_encryption.session_handle = hdcp->auth.id;
0451         hdcp_cmd->in_msg.hdcp1_enable_dp_stream_encryption.display_handle = hdcp->displays[i].index;
0452         hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_ENABLE_DP_STREAM_ENCRYPTION;
0453 
0454         psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
0455 
0456         if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
0457             status = MOD_HDCP_STATUS_HDCP1_ENABLE_STREAM_ENCRYPTION_FAILURE;
0458             break;
0459         }
0460 
0461         hdcp->displays[i].state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;
0462         HDCP_HDCP1_ENABLED_TRACE(hdcp, hdcp->displays[i].index);
0463     }
0464 
0465     mutex_unlock(&psp->hdcp_context.mutex);
0466     return status;
0467 }
0468 
0469 enum mod_hdcp_status mod_hdcp_hdcp1_link_maintenance(struct mod_hdcp *hdcp)
0470 {
0471     struct psp_context *psp = hdcp->config.psp.handle;
0472     struct ta_hdcp_shared_memory *hdcp_cmd;
0473     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0474 
0475     mutex_lock(&psp->hdcp_context.mutex);
0476     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
0477 
0478     memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
0479 
0480     hdcp_cmd->in_msg.hdcp1_get_encryption_status.session_handle = hdcp->auth.id;
0481 
0482     hdcp_cmd->out_msg.hdcp1_get_encryption_status.protection_level = 0;
0483     hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_GET_ENCRYPTION_STATUS;
0484 
0485     psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
0486 
0487     if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS ||
0488             hdcp_cmd->out_msg.hdcp1_get_encryption_status.protection_level != 1)
0489         status = MOD_HDCP_STATUS_HDCP1_LINK_MAINTENANCE_FAILURE;
0490 
0491     mutex_unlock(&psp->hdcp_context.mutex);
0492     return status;
0493 }
0494 
0495 enum mod_hdcp_status mod_hdcp_hdcp2_create_session(struct mod_hdcp *hdcp)
0496 {
0497     struct psp_context *psp = hdcp->config.psp.handle;
0498     struct ta_hdcp_shared_memory *hdcp_cmd;
0499     struct mod_hdcp_display *display = get_first_active_display(hdcp);
0500     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0501 
0502 
0503     if (!psp->hdcp_context.context.initialized) {
0504         DRM_ERROR("Failed to create hdcp session, HDCP TA is not initialized");
0505         return MOD_HDCP_STATUS_FAILURE;
0506     }
0507 
0508     if (!display)
0509         return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
0510 
0511     mutex_lock(&psp->hdcp_context.mutex);
0512 
0513     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
0514     memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
0515 
0516     hdcp_cmd->in_msg.hdcp2_create_session_v2.display_handle = display->index;
0517 
0518     if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_0)
0519         hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type =
0520             TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__FORCE_TYPE0;
0521     else if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_1)
0522         hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type =
0523             TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__FORCE_TYPE1;
0524     else if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_MAX)
0525         hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type =
0526             TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__MAX_SUPPORTED;
0527 
0528     hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_CREATE_SESSION_V2;
0529 
0530     psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
0531 
0532 
0533     if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
0534         status = MOD_HDCP_STATUS_HDCP2_CREATE_SESSION_FAILURE;
0535     else
0536         hdcp->auth.id = hdcp_cmd->out_msg.hdcp2_create_session_v2.session_handle;
0537 
0538     mutex_unlock(&psp->hdcp_context.mutex);
0539     return status;
0540 }
0541 
0542 enum mod_hdcp_status mod_hdcp_hdcp2_destroy_session(struct mod_hdcp *hdcp)
0543 {
0544     struct psp_context *psp = hdcp->config.psp.handle;
0545     struct ta_hdcp_shared_memory *hdcp_cmd;
0546     uint8_t i = 0;
0547     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0548 
0549     mutex_lock(&psp->hdcp_context.mutex);
0550     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
0551     memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
0552 
0553     hdcp_cmd->in_msg.hdcp2_destroy_session.session_handle = hdcp->auth.id;
0554     hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_DESTROY_SESSION;
0555 
0556     psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
0557 
0558     if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
0559         status = MOD_HDCP_STATUS_HDCP2_DESTROY_SESSION_FAILURE;
0560     } else {
0561         HDCP_TOP_HDCP2_DESTROY_SESSION_TRACE(hdcp);
0562         for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++)
0563             if (is_display_encryption_enabled(&hdcp->displays[i])) {
0564                 hdcp->displays[i].state =
0565                             MOD_HDCP_DISPLAY_ACTIVE;
0566                 HDCP_HDCP2_DISABLED_TRACE(
0567                     hdcp, hdcp->displays[i].index);
0568             }
0569     }
0570 
0571     mutex_unlock(&psp->hdcp_context.mutex);
0572     return status;
0573 }
0574 
0575 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_ake_init(struct mod_hdcp *hdcp)
0576 {
0577     struct psp_context *psp = hdcp->config.psp.handle;
0578     struct ta_hdcp_shared_memory *hdcp_cmd;
0579     struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
0580     struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
0581     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0582 
0583     mutex_lock(&psp->hdcp_context.mutex);
0584     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
0585     memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
0586 
0587     msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
0588     msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
0589 
0590     hdcp2_message_init(hdcp, msg_in);
0591 
0592     hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
0593     msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__AKE_INIT;
0594 
0595     psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
0596 
0597     if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
0598         status = MOD_HDCP_STATUS_HDCP2_PREP_AKE_INIT_FAILURE;
0599     else
0600         memcpy(&hdcp->auth.msg.hdcp2.ake_init[0], &msg_out->prepare.transmitter_message[0],
0601                sizeof(hdcp->auth.msg.hdcp2.ake_init));
0602 
0603     mutex_unlock(&psp->hdcp_context.mutex);
0604     return status;
0605 }
0606 
0607 enum mod_hdcp_status mod_hdcp_hdcp2_validate_ake_cert(struct mod_hdcp *hdcp)
0608 {
0609     struct psp_context *psp = hdcp->config.psp.handle;
0610     struct ta_hdcp_shared_memory *hdcp_cmd;
0611     struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
0612     struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
0613     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0614 
0615     mutex_lock(&psp->hdcp_context.mutex);
0616     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
0617     memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
0618 
0619     msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
0620     msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
0621 
0622     hdcp2_message_init(hdcp, msg_in);
0623 
0624     msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_CERT;
0625     msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_CERT;
0626 
0627     memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.ake_cert,
0628            sizeof(hdcp->auth.msg.hdcp2.ake_cert));
0629 
0630     msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__AKE_NO_STORED_KM;
0631     msg_in->prepare.msg2_id = TA_HDCP_HDCP2_MSG_ID__AKE_STORED_KM;
0632 
0633     hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
0634 
0635     psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
0636 
0637     if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
0638         status = MOD_HDCP_STATUS_HDCP2_VALIDATE_AKE_CERT_FAILURE;
0639     } else {
0640         memcpy(hdcp->auth.msg.hdcp2.ake_no_stored_km,
0641                &msg_out->prepare.transmitter_message[0],
0642                sizeof(hdcp->auth.msg.hdcp2.ake_no_stored_km));
0643 
0644         memcpy(hdcp->auth.msg.hdcp2.ake_stored_km,
0645                &msg_out->prepare.transmitter_message[sizeof(hdcp->auth.msg.hdcp2.ake_no_stored_km)],
0646                sizeof(hdcp->auth.msg.hdcp2.ake_stored_km));
0647 
0648         if (msg_out->process.msg1_status ==
0649             TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) {
0650             hdcp->connection.is_km_stored =
0651                 msg_out->process.is_km_stored ? 1 : 0;
0652             hdcp->connection.is_repeater =
0653                 msg_out->process.is_repeater ? 1 : 0;
0654             status = MOD_HDCP_STATUS_SUCCESS;
0655         } else if (msg_out->process.msg1_status ==
0656                TA_HDCP2_MSG_AUTHENTICATION_STATUS__RECEIVERID_REVOKED) {
0657             hdcp->connection.is_hdcp2_revoked = 1;
0658             status = MOD_HDCP_STATUS_HDCP2_AKE_CERT_REVOKED;
0659         }  else {
0660             status = MOD_HDCP_STATUS_HDCP2_VALIDATE_AKE_CERT_FAILURE;
0661         }
0662     }
0663     mutex_unlock(&psp->hdcp_context.mutex);
0664     return status;
0665 }
0666 
0667 enum mod_hdcp_status mod_hdcp_hdcp2_validate_h_prime(struct mod_hdcp *hdcp)
0668 {
0669     struct psp_context *psp = hdcp->config.psp.handle;
0670     struct ta_hdcp_shared_memory *hdcp_cmd;
0671     struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
0672     struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
0673     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0674 
0675     mutex_lock(&psp->hdcp_context.mutex);
0676     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
0677     memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
0678 
0679     msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
0680     msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
0681 
0682     hdcp2_message_init(hdcp, msg_in);
0683 
0684     msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_H_PRIME;
0685     msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_H_PRIME;
0686 
0687     memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.ake_h_prime,
0688            sizeof(hdcp->auth.msg.hdcp2.ake_h_prime));
0689 
0690     if (!hdcp->connection.is_km_stored) {
0691         msg_in->process.msg2_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_PAIRING_INFO;
0692         msg_in->process.msg2_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_PAIRING_INFO;
0693         memcpy(&msg_in->process.receiver_message[sizeof(hdcp->auth.msg.hdcp2.ake_h_prime)],
0694                hdcp->auth.msg.hdcp2.ake_pairing_info, sizeof(hdcp->auth.msg.hdcp2.ake_pairing_info));
0695     }
0696 
0697     hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
0698 
0699     psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
0700 
0701     if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
0702         status = MOD_HDCP_STATUS_HDCP2_VALIDATE_H_PRIME_FAILURE;
0703     else if (msg_out->process.msg1_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS)
0704         status = MOD_HDCP_STATUS_HDCP2_VALIDATE_H_PRIME_FAILURE;
0705     else if (!hdcp->connection.is_km_stored &&
0706            msg_out->process.msg2_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS)
0707         status = MOD_HDCP_STATUS_HDCP2_VALIDATE_PAIRING_INFO_FAILURE;
0708 
0709     mutex_unlock(&psp->hdcp_context.mutex);
0710     return status;
0711 }
0712 
0713 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_lc_init(struct mod_hdcp *hdcp)
0714 {
0715     struct psp_context *psp = hdcp->config.psp.handle;
0716     struct ta_hdcp_shared_memory *hdcp_cmd;
0717     struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
0718     struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
0719     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0720 
0721     mutex_lock(&psp->hdcp_context.mutex);
0722     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
0723     memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
0724 
0725     msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
0726     msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
0727 
0728     hdcp2_message_init(hdcp, msg_in);
0729 
0730     msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__LC_INIT;
0731 
0732     hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
0733 
0734     psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
0735 
0736     if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
0737         status = MOD_HDCP_STATUS_HDCP2_PREP_LC_INIT_FAILURE;
0738     else
0739         memcpy(hdcp->auth.msg.hdcp2.lc_init, &msg_out->prepare.transmitter_message[0],
0740                sizeof(hdcp->auth.msg.hdcp2.lc_init));
0741 
0742     mutex_unlock(&psp->hdcp_context.mutex);
0743     return status;
0744 }
0745 
0746 enum mod_hdcp_status mod_hdcp_hdcp2_validate_l_prime(struct mod_hdcp *hdcp)
0747 {
0748     struct psp_context *psp = hdcp->config.psp.handle;
0749     struct ta_hdcp_shared_memory *hdcp_cmd;
0750     struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
0751     struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
0752     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0753 
0754     mutex_lock(&psp->hdcp_context.mutex);
0755     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
0756     memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
0757 
0758     msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
0759     msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
0760 
0761     hdcp2_message_init(hdcp, msg_in);
0762 
0763     msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__LC_SEND_L_PRIME;
0764     msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__LC_SEND_L_PRIME;
0765 
0766     memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.lc_l_prime,
0767            sizeof(hdcp->auth.msg.hdcp2.lc_l_prime));
0768 
0769     hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
0770 
0771     psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
0772 
0773     if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS ||
0774             msg_out->process.msg1_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS)
0775         status = MOD_HDCP_STATUS_HDCP2_VALIDATE_L_PRIME_FAILURE;
0776 
0777     mutex_unlock(&psp->hdcp_context.mutex);
0778     return status;
0779 }
0780 
0781 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_eks(struct mod_hdcp *hdcp)
0782 {
0783     struct psp_context *psp = hdcp->config.psp.handle;
0784     struct ta_hdcp_shared_memory *hdcp_cmd;
0785     struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
0786     struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
0787     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0788 
0789     mutex_lock(&psp->hdcp_context.mutex);
0790     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
0791     memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
0792 
0793     msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
0794     msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
0795 
0796     hdcp2_message_init(hdcp, msg_in);
0797 
0798     msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__SKE_SEND_EKS;
0799 
0800     if (is_dp_hdcp(hdcp))
0801         msg_in->prepare.msg2_id = TA_HDCP_HDCP2_MSG_ID__SIGNAL_CONTENT_STREAM_TYPE_DP;
0802 
0803     hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
0804     psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
0805 
0806     if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
0807         status = MOD_HDCP_STATUS_HDCP2_PREP_EKS_FAILURE;
0808     } else {
0809         memcpy(hdcp->auth.msg.hdcp2.ske_eks,
0810                &msg_out->prepare.transmitter_message[0],
0811                sizeof(hdcp->auth.msg.hdcp2.ske_eks));
0812         msg_out->prepare.msg1_desc.msg_size =
0813             sizeof(hdcp->auth.msg.hdcp2.ske_eks);
0814 
0815         if (is_dp_hdcp(hdcp)) {
0816             memcpy(hdcp->auth.msg.hdcp2.content_stream_type_dp,
0817                    &msg_out->prepare.transmitter_message[sizeof(hdcp->auth.msg.hdcp2.ske_eks)],
0818                    sizeof(hdcp->auth.msg.hdcp2.content_stream_type_dp));
0819         }
0820     }
0821     mutex_unlock(&psp->hdcp_context.mutex);
0822 
0823     return status;
0824 }
0825 
0826 enum mod_hdcp_status mod_hdcp_hdcp2_enable_encryption(struct mod_hdcp *hdcp)
0827 {
0828     struct psp_context *psp = hdcp->config.psp.handle;
0829     struct ta_hdcp_shared_memory *hdcp_cmd;
0830     struct mod_hdcp_display *display = get_first_active_display(hdcp);
0831     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0832 
0833     if (!display)
0834         return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND;
0835 
0836     mutex_lock(&psp->hdcp_context.mutex);
0837 
0838     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
0839     memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
0840 
0841     hdcp_cmd->in_msg.hdcp2_set_encryption.session_handle = hdcp->auth.id;
0842 
0843     hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_SET_ENCRYPTION;
0844     psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
0845 
0846     if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
0847         status = MOD_HDCP_STATUS_HDCP2_ENABLE_ENCRYPTION_FAILURE;
0848     } else if (!is_dp_mst_hdcp(hdcp)) {
0849         display->state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;
0850         HDCP_HDCP2_ENABLED_TRACE(hdcp, display->index);
0851     }
0852 
0853     mutex_unlock(&psp->hdcp_context.mutex);
0854     return status;
0855 }
0856 
0857 enum mod_hdcp_status mod_hdcp_hdcp2_validate_rx_id_list(struct mod_hdcp *hdcp)
0858 {
0859     struct psp_context *psp = hdcp->config.psp.handle;
0860     struct ta_hdcp_shared_memory *hdcp_cmd;
0861     struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
0862     struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
0863     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0864 
0865     mutex_lock(&psp->hdcp_context.mutex);
0866 
0867     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
0868     memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
0869 
0870     msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
0871     msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
0872 
0873     hdcp2_message_init(hdcp, msg_in);
0874 
0875     msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_SEND_RECEIVERID_LIST;
0876     msg_in->process.msg1_desc.msg_size = sizeof(hdcp->auth.msg.hdcp2.rx_id_list);
0877     memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.rx_id_list,
0878            sizeof(hdcp->auth.msg.hdcp2.rx_id_list));
0879 
0880     msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_SEND_ACK;
0881 
0882     hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
0883 
0884     psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
0885 
0886     if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
0887         status = MOD_HDCP_STATUS_HDCP2_VALIDATE_RX_ID_LIST_FAILURE;
0888     } else {
0889         memcpy(hdcp->auth.msg.hdcp2.repeater_auth_ack,
0890                &msg_out->prepare.transmitter_message[0],
0891                sizeof(hdcp->auth.msg.hdcp2.repeater_auth_ack));
0892 
0893         if (msg_out->process.msg1_status ==
0894             TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) {
0895             hdcp->connection.is_km_stored = msg_out->process.is_km_stored ? 1 : 0;
0896             hdcp->connection.is_repeater = msg_out->process.is_repeater ? 1 : 0;
0897             status = MOD_HDCP_STATUS_SUCCESS;
0898         } else if (msg_out->process.msg1_status ==
0899                TA_HDCP2_MSG_AUTHENTICATION_STATUS__RECEIVERID_REVOKED) {
0900             hdcp->connection.is_hdcp2_revoked = 1;
0901             status = MOD_HDCP_STATUS_HDCP2_RX_ID_LIST_REVOKED;
0902         } else {
0903             status = MOD_HDCP_STATUS_HDCP2_VALIDATE_RX_ID_LIST_FAILURE;
0904         }
0905     }
0906     mutex_unlock(&psp->hdcp_context.mutex);
0907     return status;
0908 }
0909 
0910 enum mod_hdcp_status mod_hdcp_hdcp2_enable_dp_stream_encryption(struct mod_hdcp *hdcp)
0911 {
0912     struct psp_context *psp = hdcp->config.psp.handle;
0913     struct ta_hdcp_shared_memory *hdcp_cmd;
0914     struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
0915     uint8_t i;
0916     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0917 
0918     mutex_lock(&psp->hdcp_context.mutex);
0919     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
0920     memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
0921 
0922     msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
0923 
0924     hdcp2_message_init(hdcp, msg_in);
0925 
0926 
0927     for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) {
0928         if (hdcp->displays[i].adjust.disable || hdcp->displays[i].state != MOD_HDCP_DISPLAY_ACTIVE)
0929                 continue;
0930 
0931         hdcp_cmd->in_msg.hdcp2_enable_dp_stream_encryption.display_handle = hdcp->displays[i].index;
0932         hdcp_cmd->in_msg.hdcp2_enable_dp_stream_encryption.session_handle = hdcp->auth.id;
0933 
0934         hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_ENABLE_DP_STREAM_ENCRYPTION;
0935         psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
0936 
0937         if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS)
0938             break;
0939 
0940         hdcp->displays[i].state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED;
0941         HDCP_HDCP2_ENABLED_TRACE(hdcp, hdcp->displays[i].index);
0942     }
0943 
0944     if (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS)
0945         status = MOD_HDCP_STATUS_SUCCESS;
0946     else
0947         status = MOD_HDCP_STATUS_HDCP2_ENABLE_STREAM_ENCRYPTION_FAILURE;
0948 
0949     mutex_unlock(&psp->hdcp_context.mutex);
0950     return status;
0951 }
0952 
0953 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_stream_management(struct mod_hdcp *hdcp)
0954 {
0955 
0956     struct psp_context *psp = hdcp->config.psp.handle;
0957     struct ta_hdcp_shared_memory *hdcp_cmd;
0958     struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
0959     struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
0960     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0961 
0962     mutex_lock(&psp->hdcp_context.mutex);
0963     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
0964     memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
0965 
0966     msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
0967     msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
0968 
0969     hdcp2_message_init(hdcp, msg_in);
0970 
0971     msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_STREAM_MANAGE;
0972 
0973 
0974     hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
0975     psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
0976 
0977     if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) {
0978         status = MOD_HDCP_STATUS_HDCP2_PREPARE_STREAM_MANAGEMENT_FAILURE;
0979     } else {
0980         hdcp->auth.msg.hdcp2.stream_manage_size = msg_out->prepare.msg1_desc.msg_size;
0981 
0982         memcpy(hdcp->auth.msg.hdcp2.repeater_auth_stream_manage,
0983                &msg_out->prepare.transmitter_message[0],
0984                sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_manage));
0985     }
0986     mutex_unlock(&psp->hdcp_context.mutex);
0987     return status;
0988 }
0989 
0990 enum mod_hdcp_status mod_hdcp_hdcp2_validate_stream_ready(struct mod_hdcp *hdcp)
0991 {
0992     struct psp_context *psp = hdcp->config.psp.handle;
0993     struct ta_hdcp_shared_memory *hdcp_cmd;
0994     struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in;
0995     struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out;
0996     enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS;
0997 
0998     mutex_lock(&psp->hdcp_context.mutex);
0999     hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf;
1000     memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory));
1001 
1002     msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2;
1003     msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2;
1004 
1005     hdcp2_message_init(hdcp, msg_in);
1006 
1007     msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_STREAM_READY;
1008 
1009     msg_in->process.msg1_desc.msg_size = sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_ready);
1010 
1011     memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.repeater_auth_stream_ready,
1012            sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_ready));
1013 
1014     hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2;
1015     psp_hdcp_invoke(psp, hdcp_cmd->cmd_id);
1016 
1017     if (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS &&
1018         msg_out->process.msg1_status == TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS)
1019         status = MOD_HDCP_STATUS_SUCCESS;
1020     else
1021         status = MOD_HDCP_STATUS_HDCP2_VALIDATE_STREAM_READY_FAILURE;
1022 
1023     mutex_unlock(&psp->hdcp_context.mutex);
1024     return status;
1025 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!