1 /* 2 * Copyright 2018 Advanced Micro Devices, Inc. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included in 12 * all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 * 22 * Authors: AMD 23 * 24 */ 25 26 #define MAX_NUM_DISPLAYS 24 27 28 29 #include "hdcp.h" 30 31 #include "amdgpu.h" 32 #include "hdcp_psp.h" 33 34 static void hdcp2_message_init(struct mod_hdcp *hdcp, 35 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *in) 36 { 37 in->session_handle = hdcp->auth.id; 38 in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE; 39 in->prepare.msg2_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE; 40 in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE; 41 in->process.msg1_desc.msg_size = 0; 42 in->process.msg2_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE; 43 in->process.msg2_desc.msg_size = 0; 44 in->process.msg3_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__NULL_MESSAGE; 45 in->process.msg3_desc.msg_size = 0; 46 } 47 enum mod_hdcp_status mod_hdcp_remove_display_from_topology( 48 struct mod_hdcp *hdcp, uint8_t index) 49 { 50 struct psp_context *psp = hdcp->config.psp.handle; 51 struct ta_dtm_shared_memory *dtm_cmd; 52 struct mod_hdcp_display *display = 53 get_active_display_at_index(hdcp, index); 54 55 dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.dtm_shared_buf; 56 57 if (!display || !is_display_active(display)) 58 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND; 59 60 memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory)); 61 62 dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V2; 63 dtm_cmd->dtm_in_message.topology_update_v2.display_handle = display->index; 64 dtm_cmd->dtm_in_message.topology_update_v2.is_active = 0; 65 dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE; 66 67 psp_dtm_invoke(psp, dtm_cmd->cmd_id); 68 69 if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) 70 return MOD_HDCP_STATUS_UPDATE_TOPOLOGY_FAILURE; 71 72 display->state = MOD_HDCP_DISPLAY_ACTIVE; 73 HDCP_TOP_REMOVE_DISPLAY_TRACE(hdcp, display->index); 74 75 return MOD_HDCP_STATUS_SUCCESS; 76 } 77 78 enum mod_hdcp_status mod_hdcp_add_display_to_topology( 79 struct mod_hdcp *hdcp, struct mod_hdcp_display *display) 80 { 81 struct psp_context *psp = hdcp->config.psp.handle; 82 struct ta_dtm_shared_memory *dtm_cmd; 83 struct mod_hdcp_link *link = &hdcp->connection.link; 84 85 if (!psp->dtm_context.dtm_initialized) { 86 DRM_ERROR("Failed to add display topology, DTM TA is not initialized."); 87 display->state = MOD_HDCP_DISPLAY_INACTIVE; 88 return MOD_HDCP_STATUS_FAILURE; 89 } 90 91 dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.dtm_shared_buf; 92 93 memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory)); 94 95 dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V2; 96 dtm_cmd->dtm_in_message.topology_update_v2.display_handle = display->index; 97 dtm_cmd->dtm_in_message.topology_update_v2.is_active = 1; 98 dtm_cmd->dtm_in_message.topology_update_v2.controller = display->controller; 99 dtm_cmd->dtm_in_message.topology_update_v2.ddc_line = link->ddc_line; 100 dtm_cmd->dtm_in_message.topology_update_v2.dig_be = link->dig_be; 101 dtm_cmd->dtm_in_message.topology_update_v2.dig_fe = display->dig_fe; 102 if (is_dp_hdcp(hdcp)) 103 dtm_cmd->dtm_in_message.topology_update_v2.is_assr = link->dp.assr_supported; 104 105 dtm_cmd->dtm_in_message.topology_update_v2.dp_mst_vcid = display->vc_id; 106 dtm_cmd->dtm_in_message.topology_update_v2.max_hdcp_supported_version = 107 TA_DTM_HDCP_VERSION_MAX_SUPPORTED__2_2; 108 dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE; 109 110 psp_dtm_invoke(psp, dtm_cmd->cmd_id); 111 112 if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) { 113 display->state = MOD_HDCP_DISPLAY_INACTIVE; 114 return MOD_HDCP_STATUS_UPDATE_TOPOLOGY_FAILURE; 115 } 116 117 HDCP_TOP_ADD_DISPLAY_TRACE(hdcp, display->index); 118 119 return MOD_HDCP_STATUS_SUCCESS; 120 } 121 122 enum mod_hdcp_status mod_hdcp_hdcp1_create_session(struct mod_hdcp *hdcp) 123 { 124 125 struct psp_context *psp = hdcp->config.psp.handle; 126 struct mod_hdcp_display *display = get_first_active_display(hdcp); 127 struct ta_hdcp_shared_memory *hdcp_cmd; 128 129 if (!psp->hdcp_context.hdcp_initialized) { 130 DRM_ERROR("Failed to create hdcp session. HDCP TA is not initialized."); 131 return MOD_HDCP_STATUS_FAILURE; 132 } 133 134 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 135 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 136 137 hdcp_cmd->in_msg.hdcp1_create_session.display_handle = display->index; 138 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_CREATE_SESSION; 139 140 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 141 142 hdcp->auth.id = hdcp_cmd->out_msg.hdcp1_create_session.session_handle; 143 144 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 145 return MOD_HDCP_STATUS_HDCP1_CREATE_SESSION_FAILURE; 146 147 hdcp->auth.msg.hdcp1.ainfo = hdcp_cmd->out_msg.hdcp1_create_session.ainfo_primary; 148 memcpy(hdcp->auth.msg.hdcp1.aksv, hdcp_cmd->out_msg.hdcp1_create_session.aksv_primary, 149 sizeof(hdcp->auth.msg.hdcp1.aksv)); 150 memcpy(hdcp->auth.msg.hdcp1.an, hdcp_cmd->out_msg.hdcp1_create_session.an_primary, 151 sizeof(hdcp->auth.msg.hdcp1.an)); 152 153 return MOD_HDCP_STATUS_SUCCESS; 154 } 155 156 enum mod_hdcp_status mod_hdcp_hdcp1_destroy_session(struct mod_hdcp *hdcp) 157 { 158 159 struct psp_context *psp = hdcp->config.psp.handle; 160 struct ta_hdcp_shared_memory *hdcp_cmd; 161 uint8_t i = 0; 162 163 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 164 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 165 166 hdcp_cmd->in_msg.hdcp1_destroy_session.session_handle = hdcp->auth.id; 167 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_DESTROY_SESSION; 168 169 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 170 171 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 172 return MOD_HDCP_STATUS_HDCP1_DESTROY_SESSION_FAILURE; 173 174 HDCP_TOP_HDCP1_DESTROY_SESSION_TRACE(hdcp); 175 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) 176 if (is_display_encryption_enabled( 177 &hdcp->displays[i])) { 178 hdcp->displays[i].state = 179 MOD_HDCP_DISPLAY_ACTIVE; 180 HDCP_HDCP1_DISABLED_TRACE(hdcp, 181 hdcp->displays[i].index); 182 } 183 184 return MOD_HDCP_STATUS_SUCCESS; 185 } 186 187 enum mod_hdcp_status mod_hdcp_hdcp1_validate_rx(struct mod_hdcp *hdcp) 188 { 189 struct psp_context *psp = hdcp->config.psp.handle; 190 struct ta_hdcp_shared_memory *hdcp_cmd; 191 192 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 193 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 194 195 hdcp_cmd->in_msg.hdcp1_first_part_authentication.session_handle = hdcp->auth.id; 196 197 memcpy(hdcp_cmd->in_msg.hdcp1_first_part_authentication.bksv_primary, hdcp->auth.msg.hdcp1.bksv, 198 TA_HDCP__HDCP1_KSV_SIZE); 199 200 hdcp_cmd->in_msg.hdcp1_first_part_authentication.r0_prime_primary = hdcp->auth.msg.hdcp1.r0p; 201 hdcp_cmd->in_msg.hdcp1_first_part_authentication.bcaps = hdcp->auth.msg.hdcp1.bcaps; 202 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_FIRST_PART_AUTHENTICATION; 203 204 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 205 206 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 207 return MOD_HDCP_STATUS_HDCP1_VALIDATE_RX_FAILURE; 208 209 if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status == 210 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_FIRST_PART_COMPLETE) { 211 /* needs second part of authentication */ 212 hdcp->connection.is_repeater = 1; 213 } else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status == 214 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_AUTHENTICATED) { 215 hdcp->connection.is_repeater = 0; 216 } else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status == 217 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_KSV_REVOKED) { 218 hdcp->connection.is_hdcp1_revoked = 1; 219 return MOD_HDCP_STATUS_HDCP1_BKSV_REVOKED; 220 } else 221 return MOD_HDCP_STATUS_HDCP1_VALIDATE_RX_FAILURE; 222 223 224 return MOD_HDCP_STATUS_SUCCESS; 225 } 226 227 enum mod_hdcp_status mod_hdcp_hdcp1_enable_encryption(struct mod_hdcp *hdcp) 228 { 229 struct psp_context *psp = hdcp->config.psp.handle; 230 struct ta_hdcp_shared_memory *hdcp_cmd; 231 struct mod_hdcp_display *display = get_first_active_display(hdcp); 232 233 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 234 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 235 236 hdcp_cmd->in_msg.hdcp1_enable_encryption.session_handle = hdcp->auth.id; 237 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_ENABLE_ENCRYPTION; 238 239 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 240 241 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 242 return MOD_HDCP_STATUS_HDCP1_ENABLE_ENCRYPTION; 243 244 if (!is_dp_mst_hdcp(hdcp)) { 245 display->state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED; 246 HDCP_HDCP1_ENABLED_TRACE(hdcp, display->index); 247 } 248 return MOD_HDCP_STATUS_SUCCESS; 249 } 250 251 enum mod_hdcp_status mod_hdcp_hdcp1_validate_ksvlist_vp(struct mod_hdcp *hdcp) 252 { 253 struct psp_context *psp = hdcp->config.psp.handle; 254 struct ta_hdcp_shared_memory *hdcp_cmd; 255 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 256 257 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 258 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 259 260 hdcp_cmd->in_msg.hdcp1_second_part_authentication.session_handle = hdcp->auth.id; 261 262 hdcp_cmd->in_msg.hdcp1_second_part_authentication.ksv_list_size = hdcp->auth.msg.hdcp1.ksvlist_size; 263 memcpy(hdcp_cmd->in_msg.hdcp1_second_part_authentication.ksv_list, hdcp->auth.msg.hdcp1.ksvlist, 264 hdcp->auth.msg.hdcp1.ksvlist_size); 265 266 memcpy(hdcp_cmd->in_msg.hdcp1_second_part_authentication.v_prime, hdcp->auth.msg.hdcp1.vp, 267 sizeof(hdcp->auth.msg.hdcp1.vp)); 268 269 hdcp_cmd->in_msg.hdcp1_second_part_authentication.bstatus_binfo = 270 is_dp_hdcp(hdcp) ? hdcp->auth.msg.hdcp1.binfo_dp : hdcp->auth.msg.hdcp1.bstatus; 271 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_SECOND_PART_AUTHENTICATION; 272 273 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 274 275 if (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS && 276 hdcp_cmd->out_msg.hdcp1_second_part_authentication.authentication_status == 277 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_AUTHENTICATED) { 278 status = MOD_HDCP_STATUS_SUCCESS; 279 } else if (hdcp_cmd->out_msg.hdcp1_second_part_authentication.authentication_status == 280 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_KSV_REVOKED) { 281 hdcp->connection.is_hdcp1_revoked = 1; 282 status = MOD_HDCP_STATUS_HDCP1_KSV_LIST_REVOKED; 283 } else { 284 status = MOD_HDCP_STATUS_HDCP1_VALIDATE_KSV_LIST_FAILURE; 285 } 286 287 return status; 288 } 289 290 enum mod_hdcp_status mod_hdcp_hdcp1_enable_dp_stream_encryption(struct mod_hdcp *hdcp) 291 { 292 293 struct psp_context *psp = hdcp->config.psp.handle; 294 struct ta_hdcp_shared_memory *hdcp_cmd; 295 int i = 0; 296 297 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 298 299 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) { 300 301 if (hdcp->displays[i].adjust.disable) 302 continue; 303 304 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 305 306 hdcp_cmd->in_msg.hdcp1_enable_dp_stream_encryption.session_handle = hdcp->auth.id; 307 hdcp_cmd->in_msg.hdcp1_enable_dp_stream_encryption.display_handle = hdcp->displays[i].index; 308 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_ENABLE_DP_STREAM_ENCRYPTION; 309 310 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 311 312 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 313 return MOD_HDCP_STATUS_HDCP1_ENABLE_STREAM_ENCRYPTION_FAILURE; 314 315 hdcp->displays[i].state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED; 316 HDCP_HDCP1_ENABLED_TRACE(hdcp, hdcp->displays[i].index); 317 } 318 319 return MOD_HDCP_STATUS_SUCCESS; 320 } 321 322 enum mod_hdcp_status mod_hdcp_hdcp1_link_maintenance(struct mod_hdcp *hdcp) 323 { 324 struct psp_context *psp = hdcp->config.psp.handle; 325 struct ta_hdcp_shared_memory *hdcp_cmd; 326 327 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 328 329 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 330 331 hdcp_cmd->in_msg.hdcp1_get_encryption_status.session_handle = hdcp->auth.id; 332 333 hdcp_cmd->out_msg.hdcp1_get_encryption_status.protection_level = 0; 334 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_GET_ENCRYPTION_STATUS; 335 336 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 337 338 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 339 return MOD_HDCP_STATUS_HDCP1_LINK_MAINTENANCE_FAILURE; 340 341 return (hdcp_cmd->out_msg.hdcp1_get_encryption_status.protection_level == 1) 342 ? MOD_HDCP_STATUS_SUCCESS 343 : MOD_HDCP_STATUS_HDCP1_LINK_MAINTENANCE_FAILURE; 344 } 345 346 enum mod_hdcp_status mod_hdcp_hdcp1_get_link_encryption_status(struct mod_hdcp *hdcp, 347 enum mod_hdcp_encryption_status *encryption_status) 348 { 349 *encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF; 350 351 if (mod_hdcp_hdcp1_link_maintenance(hdcp) != MOD_HDCP_STATUS_SUCCESS) 352 return MOD_HDCP_STATUS_FAILURE; 353 354 *encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP1_ON; 355 356 return MOD_HDCP_STATUS_SUCCESS; 357 } 358 359 enum mod_hdcp_status mod_hdcp_hdcp2_create_session(struct mod_hdcp *hdcp) 360 { 361 struct psp_context *psp = hdcp->config.psp.handle; 362 struct ta_hdcp_shared_memory *hdcp_cmd; 363 struct mod_hdcp_display *display = get_first_active_display(hdcp); 364 365 if (!psp->hdcp_context.hdcp_initialized) { 366 DRM_ERROR("Failed to create hdcp session, HDCP TA is not initialized"); 367 return MOD_HDCP_STATUS_FAILURE; 368 } 369 370 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 371 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 372 373 if (!display) 374 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND; 375 376 hdcp_cmd->in_msg.hdcp2_create_session_v2.display_handle = display->index; 377 378 if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_0) 379 hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type = 380 TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__FORCE_TYPE0; 381 else if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_1) 382 hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type = 383 TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__FORCE_TYPE1; 384 else if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_MAX) 385 hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type = 386 TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__MAX_SUPPORTED; 387 388 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_CREATE_SESSION_V2; 389 390 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 391 392 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 393 return MOD_HDCP_STATUS_HDCP2_CREATE_SESSION_FAILURE; 394 395 hdcp->auth.id = hdcp_cmd->out_msg.hdcp2_create_session_v2.session_handle; 396 397 return MOD_HDCP_STATUS_SUCCESS; 398 } 399 400 enum mod_hdcp_status mod_hdcp_hdcp2_destroy_session(struct mod_hdcp *hdcp) 401 { 402 struct psp_context *psp = hdcp->config.psp.handle; 403 struct ta_hdcp_shared_memory *hdcp_cmd; 404 uint8_t i = 0; 405 406 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 407 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 408 409 hdcp_cmd->in_msg.hdcp2_destroy_session.session_handle = hdcp->auth.id; 410 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_DESTROY_SESSION; 411 412 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 413 414 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 415 return MOD_HDCP_STATUS_HDCP2_DESTROY_SESSION_FAILURE; 416 417 HDCP_TOP_HDCP2_DESTROY_SESSION_TRACE(hdcp); 418 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) 419 if (is_display_encryption_enabled( 420 &hdcp->displays[i])) { 421 hdcp->displays[i].state = 422 MOD_HDCP_DISPLAY_ACTIVE; 423 HDCP_HDCP2_DISABLED_TRACE(hdcp, 424 hdcp->displays[i].index); 425 } 426 427 return MOD_HDCP_STATUS_SUCCESS; 428 } 429 430 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_ake_init(struct mod_hdcp *hdcp) 431 { 432 struct psp_context *psp = hdcp->config.psp.handle; 433 struct ta_hdcp_shared_memory *hdcp_cmd; 434 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 435 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; 436 437 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 438 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 439 440 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 441 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; 442 443 hdcp2_message_init(hdcp, msg_in); 444 445 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; 446 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__AKE_INIT; 447 448 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 449 450 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 451 return MOD_HDCP_STATUS_HDCP2_PREP_AKE_INIT_FAILURE; 452 453 memcpy(&hdcp->auth.msg.hdcp2.ake_init[0], &msg_out->prepare.transmitter_message[0], 454 sizeof(hdcp->auth.msg.hdcp2.ake_init)); 455 456 return MOD_HDCP_STATUS_SUCCESS; 457 } 458 459 enum mod_hdcp_status mod_hdcp_hdcp2_validate_ake_cert(struct mod_hdcp *hdcp) 460 { 461 struct psp_context *psp = hdcp->config.psp.handle; 462 struct ta_hdcp_shared_memory *hdcp_cmd; 463 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 464 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; 465 466 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 467 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 468 469 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 470 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; 471 472 hdcp2_message_init(hdcp, msg_in); 473 474 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_CERT; 475 msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_CERT; 476 477 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.ake_cert, 478 sizeof(hdcp->auth.msg.hdcp2.ake_cert)); 479 480 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__AKE_NO_STORED_KM; 481 msg_in->prepare.msg2_id = TA_HDCP_HDCP2_MSG_ID__AKE_STORED_KM; 482 483 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; 484 485 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 486 487 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 488 return MOD_HDCP_STATUS_HDCP2_VALIDATE_AKE_CERT_FAILURE; 489 490 memcpy(hdcp->auth.msg.hdcp2.ake_no_stored_km, &msg_out->prepare.transmitter_message[0], 491 sizeof(hdcp->auth.msg.hdcp2.ake_no_stored_km)); 492 493 memcpy(hdcp->auth.msg.hdcp2.ake_stored_km, 494 &msg_out->prepare.transmitter_message[sizeof(hdcp->auth.msg.hdcp2.ake_no_stored_km)], 495 sizeof(hdcp->auth.msg.hdcp2.ake_stored_km)); 496 497 if (msg_out->process.msg1_status == TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) { 498 hdcp->connection.is_km_stored = msg_out->process.is_km_stored ? 1 : 0; 499 hdcp->connection.is_repeater = msg_out->process.is_repeater ? 1 : 0; 500 return MOD_HDCP_STATUS_SUCCESS; 501 } else if (msg_out->process.msg1_status == TA_HDCP2_MSG_AUTHENTICATION_STATUS__RECEIVERID_REVOKED) { 502 hdcp->connection.is_hdcp2_revoked = 1; 503 return MOD_HDCP_STATUS_HDCP2_AKE_CERT_REVOKED; 504 } 505 506 return MOD_HDCP_STATUS_HDCP2_VALIDATE_AKE_CERT_FAILURE; 507 } 508 509 enum mod_hdcp_status mod_hdcp_hdcp2_validate_h_prime(struct mod_hdcp *hdcp) 510 { 511 struct psp_context *psp = hdcp->config.psp.handle; 512 struct ta_hdcp_shared_memory *hdcp_cmd; 513 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 514 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; 515 516 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 517 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 518 519 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 520 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; 521 522 hdcp2_message_init(hdcp, msg_in); 523 524 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_H_PRIME; 525 msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_H_PRIME; 526 527 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.ake_h_prime, 528 sizeof(hdcp->auth.msg.hdcp2.ake_h_prime)); 529 530 if (!hdcp->connection.is_km_stored) { 531 msg_in->process.msg2_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_PAIRING_INFO; 532 msg_in->process.msg2_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_PAIRING_INFO; 533 memcpy(&msg_in->process.receiver_message[sizeof(hdcp->auth.msg.hdcp2.ake_h_prime)], 534 hdcp->auth.msg.hdcp2.ake_pairing_info, sizeof(hdcp->auth.msg.hdcp2.ake_pairing_info)); 535 } 536 537 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; 538 539 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 540 541 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 542 return MOD_HDCP_STATUS_HDCP2_VALIDATE_H_PRIME_FAILURE; 543 544 if (msg_out->process.msg1_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) 545 return MOD_HDCP_STATUS_HDCP2_VALIDATE_H_PRIME_FAILURE; 546 else if (!hdcp->connection.is_km_stored && 547 msg_out->process.msg2_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) 548 return MOD_HDCP_STATUS_HDCP2_VALIDATE_PAIRING_INFO_FAILURE; 549 550 551 return MOD_HDCP_STATUS_SUCCESS; 552 } 553 554 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_lc_init(struct mod_hdcp *hdcp) 555 { 556 struct psp_context *psp = hdcp->config.psp.handle; 557 struct ta_hdcp_shared_memory *hdcp_cmd; 558 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 559 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; 560 561 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 562 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 563 564 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 565 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; 566 567 hdcp2_message_init(hdcp, msg_in); 568 569 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__LC_INIT; 570 571 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; 572 573 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 574 575 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 576 return MOD_HDCP_STATUS_HDCP2_PREP_LC_INIT_FAILURE; 577 578 memcpy(hdcp->auth.msg.hdcp2.lc_init, &msg_out->prepare.transmitter_message[0], 579 sizeof(hdcp->auth.msg.hdcp2.lc_init)); 580 581 return MOD_HDCP_STATUS_SUCCESS; 582 } 583 584 enum mod_hdcp_status mod_hdcp_hdcp2_validate_l_prime(struct mod_hdcp *hdcp) 585 { 586 struct psp_context *psp = hdcp->config.psp.handle; 587 struct ta_hdcp_shared_memory *hdcp_cmd; 588 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 589 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; 590 591 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 592 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 593 594 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 595 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; 596 597 hdcp2_message_init(hdcp, msg_in); 598 599 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__LC_SEND_L_PRIME; 600 msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__LC_SEND_L_PRIME; 601 602 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.lc_l_prime, 603 sizeof(hdcp->auth.msg.hdcp2.lc_l_prime)); 604 605 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; 606 607 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 608 609 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 610 return MOD_HDCP_STATUS_HDCP2_VALIDATE_L_PRIME_FAILURE; 611 612 if (msg_out->process.msg1_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) 613 return MOD_HDCP_STATUS_HDCP2_VALIDATE_L_PRIME_FAILURE; 614 615 return MOD_HDCP_STATUS_SUCCESS; 616 } 617 618 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_eks(struct mod_hdcp *hdcp) 619 { 620 struct psp_context *psp = hdcp->config.psp.handle; 621 struct ta_hdcp_shared_memory *hdcp_cmd; 622 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 623 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; 624 625 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 626 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 627 628 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 629 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; 630 631 hdcp2_message_init(hdcp, msg_in); 632 633 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__SKE_SEND_EKS; 634 635 if (is_dp_hdcp(hdcp)) 636 msg_in->prepare.msg2_id = TA_HDCP_HDCP2_MSG_ID__SIGNAL_CONTENT_STREAM_TYPE_DP; 637 638 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; 639 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 640 641 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 642 return MOD_HDCP_STATUS_HDCP2_PREP_EKS_FAILURE; 643 644 memcpy(hdcp->auth.msg.hdcp2.ske_eks, &msg_out->prepare.transmitter_message[0], 645 sizeof(hdcp->auth.msg.hdcp2.ske_eks)); 646 msg_out->prepare.msg1_desc.msg_size = sizeof(hdcp->auth.msg.hdcp2.ske_eks); 647 648 if (is_dp_hdcp(hdcp)) { 649 memcpy(hdcp->auth.msg.hdcp2.content_stream_type_dp, 650 &msg_out->prepare.transmitter_message[sizeof(hdcp->auth.msg.hdcp2.ske_eks)], 651 sizeof(hdcp->auth.msg.hdcp2.content_stream_type_dp)); 652 } 653 654 return MOD_HDCP_STATUS_SUCCESS; 655 } 656 657 enum mod_hdcp_status mod_hdcp_hdcp2_enable_encryption(struct mod_hdcp *hdcp) 658 { 659 struct psp_context *psp = hdcp->config.psp.handle; 660 struct ta_hdcp_shared_memory *hdcp_cmd; 661 struct mod_hdcp_display *display = get_first_active_display(hdcp); 662 663 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 664 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 665 666 if (!display) 667 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND; 668 669 hdcp_cmd->in_msg.hdcp2_set_encryption.session_handle = hdcp->auth.id; 670 671 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_SET_ENCRYPTION; 672 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 673 674 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 675 return MOD_HDCP_STATUS_HDCP2_ENABLE_ENCRYPTION_FAILURE; 676 677 if (!is_dp_mst_hdcp(hdcp)) { 678 display->state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED; 679 HDCP_HDCP2_ENABLED_TRACE(hdcp, display->index); 680 } 681 682 return MOD_HDCP_STATUS_SUCCESS; 683 } 684 685 enum mod_hdcp_status mod_hdcp_hdcp2_validate_rx_id_list(struct mod_hdcp *hdcp) 686 { 687 struct psp_context *psp = hdcp->config.psp.handle; 688 struct ta_hdcp_shared_memory *hdcp_cmd; 689 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 690 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; 691 692 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 693 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 694 695 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 696 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; 697 698 hdcp2_message_init(hdcp, msg_in); 699 700 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_SEND_RECEIVERID_LIST; 701 msg_in->process.msg1_desc.msg_size = sizeof(hdcp->auth.msg.hdcp2.rx_id_list); 702 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.rx_id_list, 703 sizeof(hdcp->auth.msg.hdcp2.rx_id_list)); 704 705 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_SEND_ACK; 706 707 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; 708 709 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 710 711 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 712 return MOD_HDCP_STATUS_HDCP2_VALIDATE_RX_ID_LIST_FAILURE; 713 714 memcpy(hdcp->auth.msg.hdcp2.repeater_auth_ack, &msg_out->prepare.transmitter_message[0], 715 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_ack)); 716 717 if (msg_out->process.msg1_status == TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) { 718 hdcp->connection.is_km_stored = msg_out->process.is_km_stored ? 1 : 0; 719 hdcp->connection.is_repeater = msg_out->process.is_repeater ? 1 : 0; 720 return MOD_HDCP_STATUS_SUCCESS; 721 } else if (msg_out->process.msg1_status == TA_HDCP2_MSG_AUTHENTICATION_STATUS__RECEIVERID_REVOKED) { 722 hdcp->connection.is_hdcp2_revoked = 1; 723 return MOD_HDCP_STATUS_HDCP2_RX_ID_LIST_REVOKED; 724 } 725 726 727 return MOD_HDCP_STATUS_HDCP2_VALIDATE_RX_ID_LIST_FAILURE; 728 } 729 730 enum mod_hdcp_status mod_hdcp_hdcp2_enable_dp_stream_encryption(struct mod_hdcp *hdcp) 731 { 732 struct psp_context *psp = hdcp->config.psp.handle; 733 struct ta_hdcp_shared_memory *hdcp_cmd; 734 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 735 uint8_t i; 736 737 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 738 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 739 740 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 741 742 hdcp2_message_init(hdcp, msg_in); 743 744 745 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) { 746 if (hdcp->displays[i].adjust.disable) 747 continue; 748 hdcp_cmd->in_msg.hdcp2_enable_dp_stream_encryption.display_handle = hdcp->displays[i].index; 749 hdcp_cmd->in_msg.hdcp2_enable_dp_stream_encryption.session_handle = hdcp->auth.id; 750 751 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_ENABLE_DP_STREAM_ENCRYPTION; 752 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 753 754 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 755 break; 756 757 hdcp->displays[i].state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED; 758 HDCP_HDCP2_ENABLED_TRACE(hdcp, hdcp->displays[i].index); 759 } 760 761 return (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS) ? MOD_HDCP_STATUS_SUCCESS 762 : MOD_HDCP_STATUS_HDCP2_ENABLE_STREAM_ENCRYPTION; 763 } 764 765 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_stream_management(struct mod_hdcp *hdcp) 766 { 767 768 struct psp_context *psp = hdcp->config.psp.handle; 769 struct ta_hdcp_shared_memory *hdcp_cmd; 770 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 771 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; 772 773 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 774 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 775 776 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 777 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; 778 779 hdcp2_message_init(hdcp, msg_in); 780 781 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_STREAM_MANAGE; 782 783 784 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; 785 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 786 787 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 788 return MOD_HDCP_STATUS_HDCP2_PREPARE_STREAM_MANAGEMENT_FAILURE; 789 790 hdcp->auth.msg.hdcp2.stream_manage_size = msg_out->prepare.msg1_desc.msg_size; 791 792 memcpy(hdcp->auth.msg.hdcp2.repeater_auth_stream_manage, &msg_out->prepare.transmitter_message[0], 793 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_manage)); 794 795 return MOD_HDCP_STATUS_SUCCESS; 796 } 797 798 enum mod_hdcp_status mod_hdcp_hdcp2_validate_stream_ready(struct mod_hdcp *hdcp) 799 { 800 struct psp_context *psp = hdcp->config.psp.handle; 801 struct ta_hdcp_shared_memory *hdcp_cmd; 802 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 803 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; 804 805 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 806 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 807 808 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 809 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; 810 811 hdcp2_message_init(hdcp, msg_in); 812 813 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_STREAM_READY; 814 815 msg_in->process.msg1_desc.msg_size = sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_ready); 816 817 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.repeater_auth_stream_ready, 818 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_ready)); 819 820 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; 821 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 822 823 return (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS) && 824 (msg_out->process.msg1_status == TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) 825 ? MOD_HDCP_STATUS_SUCCESS 826 : MOD_HDCP_STATUS_HDCP2_VALIDATE_STREAM_READY_FAILURE; 827 } 828 829 enum mod_hdcp_status mod_hdcp_hdcp2_get_link_encryption_status(struct mod_hdcp *hdcp, 830 enum mod_hdcp_encryption_status *encryption_status) 831 { 832 struct psp_context *psp = hdcp->config.psp.handle; 833 struct ta_hdcp_shared_memory *hdcp_cmd; 834 835 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 836 837 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 838 839 hdcp_cmd->in_msg.hdcp2_get_encryption_status.session_handle = hdcp->auth.id; 840 hdcp_cmd->out_msg.hdcp2_get_encryption_status.protection_level = 0; 841 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_GET_ENCRYPTION_STATUS; 842 *encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF; 843 844 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 845 846 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 847 return MOD_HDCP_STATUS_FAILURE; 848 849 if (hdcp_cmd->out_msg.hdcp2_get_encryption_status.protection_level == 1) { 850 if (hdcp_cmd->out_msg.hdcp2_get_encryption_status.hdcp2_type == TA_HDCP2_CONTENT_TYPE__TYPE1) 851 *encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON; 852 else 853 *encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE0_ON; 854 } 855 856 return MOD_HDCP_STATUS_SUCCESS; 857 } 858