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