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