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 #if defined(CONFIG_DRM_AMD_DC_DCN3_1) 48 static enum mod_hdcp_status mod_hdcp_remove_display_from_topology_v2( 49 struct mod_hdcp *hdcp, uint8_t index) 50 #else 51 enum mod_hdcp_status mod_hdcp_remove_display_from_topology( 52 struct mod_hdcp *hdcp, uint8_t index) 53 #endif 54 { 55 struct psp_context *psp = hdcp->config.psp.handle; 56 struct ta_dtm_shared_memory *dtm_cmd; 57 struct mod_hdcp_display *display = 58 get_active_display_at_index(hdcp, index); 59 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 60 61 dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.dtm_shared_buf; 62 63 if (!display || !is_display_active(display)) 64 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND; 65 66 mutex_lock(&psp->dtm_context.mutex); 67 68 memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory)); 69 70 dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V2; 71 dtm_cmd->dtm_in_message.topology_update_v2.display_handle = display->index; 72 dtm_cmd->dtm_in_message.topology_update_v2.is_active = 0; 73 dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE; 74 75 psp_dtm_invoke(psp, dtm_cmd->cmd_id); 76 77 if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) { 78 status = MOD_HDCP_STATUS_UPDATE_TOPOLOGY_FAILURE; 79 } else { 80 display->state = MOD_HDCP_DISPLAY_ACTIVE; 81 HDCP_TOP_REMOVE_DISPLAY_TRACE(hdcp, display->index); 82 } 83 84 mutex_unlock(&psp->dtm_context.mutex); 85 return status; 86 } 87 #if defined(CONFIG_DRM_AMD_DC_DCN3_1) 88 static enum mod_hdcp_status mod_hdcp_remove_display_from_topology_v3( 89 struct mod_hdcp *hdcp, uint8_t index) 90 { 91 struct psp_context *psp = hdcp->config.psp.handle; 92 struct ta_dtm_shared_memory *dtm_cmd; 93 struct mod_hdcp_display *display = 94 get_active_display_at_index(hdcp, index); 95 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 96 97 dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.dtm_shared_buf; 98 99 if (!display || !is_display_active(display)) 100 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND; 101 102 mutex_lock(&psp->dtm_context.mutex); 103 104 memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory)); 105 106 dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V3; 107 dtm_cmd->dtm_in_message.topology_update_v3.display_handle = display->index; 108 dtm_cmd->dtm_in_message.topology_update_v3.is_active = 0; 109 dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE; 110 111 psp_dtm_invoke(psp, dtm_cmd->cmd_id); 112 113 if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) { 114 status = mod_hdcp_remove_display_from_topology_v2(hdcp, index); 115 if (status != MOD_HDCP_STATUS_SUCCESS) 116 display->state = MOD_HDCP_DISPLAY_INACTIVE; 117 } else { 118 display->state = MOD_HDCP_DISPLAY_ACTIVE; 119 HDCP_TOP_REMOVE_DISPLAY_TRACE(hdcp, display->index); 120 } 121 122 mutex_unlock(&psp->dtm_context.mutex); 123 124 return status; 125 } 126 127 enum mod_hdcp_status mod_hdcp_remove_display_from_topology( 128 struct mod_hdcp *hdcp, uint8_t index) 129 { 130 enum mod_hdcp_status status = MOD_HDCP_STATUS_UPDATE_TOPOLOGY_FAILURE; 131 132 if (hdcp->config.psp.caps.dtm_v3_supported) 133 status = mod_hdcp_remove_display_from_topology_v3(hdcp, index); 134 else 135 status = mod_hdcp_remove_display_from_topology_v2(hdcp, index); 136 137 return status; 138 } 139 #endif 140 #if defined(CONFIG_DRM_AMD_DC_DCN3_1) 141 static enum mod_hdcp_status mod_hdcp_add_display_to_topology_v2( 142 struct mod_hdcp *hdcp, struct mod_hdcp_display *display) 143 #else 144 enum mod_hdcp_status mod_hdcp_add_display_to_topology(struct mod_hdcp *hdcp, 145 struct mod_hdcp_display *display) 146 #endif 147 { 148 struct psp_context *psp = hdcp->config.psp.handle; 149 struct ta_dtm_shared_memory *dtm_cmd; 150 struct mod_hdcp_link *link = &hdcp->connection.link; 151 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 152 153 if (!psp->dtm_context.dtm_initialized) { 154 DRM_INFO("Failed to add display topology, DTM TA is not initialized."); 155 display->state = MOD_HDCP_DISPLAY_INACTIVE; 156 return MOD_HDCP_STATUS_FAILURE; 157 } 158 159 dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.dtm_shared_buf; 160 161 mutex_lock(&psp->dtm_context.mutex); 162 memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory)); 163 164 dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V2; 165 dtm_cmd->dtm_in_message.topology_update_v2.display_handle = display->index; 166 dtm_cmd->dtm_in_message.topology_update_v2.is_active = 1; 167 dtm_cmd->dtm_in_message.topology_update_v2.controller = display->controller; 168 dtm_cmd->dtm_in_message.topology_update_v2.ddc_line = link->ddc_line; 169 dtm_cmd->dtm_in_message.topology_update_v2.dig_be = link->dig_be; 170 dtm_cmd->dtm_in_message.topology_update_v2.dig_fe = display->dig_fe; 171 if (is_dp_hdcp(hdcp)) 172 dtm_cmd->dtm_in_message.topology_update_v2.is_assr = link->dp.assr_enabled; 173 174 dtm_cmd->dtm_in_message.topology_update_v2.dp_mst_vcid = display->vc_id; 175 dtm_cmd->dtm_in_message.topology_update_v2.max_hdcp_supported_version = 176 TA_DTM_HDCP_VERSION_MAX_SUPPORTED__2_2; 177 dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE; 178 179 psp_dtm_invoke(psp, dtm_cmd->cmd_id); 180 181 if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) { 182 display->state = MOD_HDCP_DISPLAY_INACTIVE; 183 status = MOD_HDCP_STATUS_UPDATE_TOPOLOGY_FAILURE; 184 } else { 185 HDCP_TOP_ADD_DISPLAY_TRACE(hdcp, display->index); 186 } 187 188 mutex_unlock(&psp->dtm_context.mutex); 189 return status; 190 } 191 192 #if defined(CONFIG_DRM_AMD_DC_DCN3_1) 193 static enum mod_hdcp_status mod_hdcp_add_display_to_topology_v3( 194 struct mod_hdcp *hdcp, struct mod_hdcp_display *display) 195 { 196 struct psp_context *psp = hdcp->config.psp.handle; 197 struct ta_dtm_shared_memory *dtm_cmd; 198 struct mod_hdcp_link *link = &hdcp->connection.link; 199 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 200 201 if (!psp->dtm_context.dtm_initialized) { 202 DRM_INFO("Failed to add display topology, DTM TA is not initialized."); 203 display->state = MOD_HDCP_DISPLAY_INACTIVE; 204 return MOD_HDCP_STATUS_FAILURE; 205 } 206 207 dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.dtm_shared_buf; 208 209 mutex_lock(&psp->dtm_context.mutex); 210 memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory)); 211 212 dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V3; 213 dtm_cmd->dtm_in_message.topology_update_v3.display_handle = display->index; 214 dtm_cmd->dtm_in_message.topology_update_v3.is_active = 1; 215 dtm_cmd->dtm_in_message.topology_update_v3.controller = display->controller; 216 dtm_cmd->dtm_in_message.topology_update_v3.ddc_line = link->ddc_line; 217 dtm_cmd->dtm_in_message.topology_update_v3.link_enc = link->link_enc_idx; 218 dtm_cmd->dtm_in_message.topology_update_v3.stream_enc = display->stream_enc_idx; 219 if (is_dp_hdcp(hdcp)) 220 dtm_cmd->dtm_in_message.topology_update_v3.is_assr = link->dp.assr_enabled; 221 222 dtm_cmd->dtm_in_message.topology_update_v3.dp_mst_vcid = display->vc_id; 223 dtm_cmd->dtm_in_message.topology_update_v3.max_hdcp_supported_version = 224 TA_DTM_HDCP_VERSION_MAX_SUPPORTED__2_3; 225 dtm_cmd->dtm_in_message.topology_update_v3.encoder_type = TA_DTM_ENCODER_TYPE__DIG; 226 dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE; 227 dtm_cmd->dtm_in_message.topology_update_v3.phy_id = link->phy_idx; 228 dtm_cmd->dtm_in_message.topology_update_v3.link_hdcp_cap = link->hdcp_supported_informational; 229 230 psp_dtm_invoke(psp, dtm_cmd->cmd_id); 231 232 if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) { 233 status = mod_hdcp_add_display_to_topology_v2(hdcp, display); 234 if (status != MOD_HDCP_STATUS_SUCCESS) 235 display->state = MOD_HDCP_DISPLAY_INACTIVE; 236 } else { 237 HDCP_TOP_ADD_DISPLAY_TRACE(hdcp, display->index); 238 } 239 240 mutex_unlock(&psp->dtm_context.mutex); 241 242 return status; 243 } 244 245 enum mod_hdcp_status mod_hdcp_add_display_to_topology(struct mod_hdcp *hdcp, 246 struct mod_hdcp_display *display) 247 { 248 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 249 250 if (hdcp->config.psp.caps.dtm_v3_supported) 251 status = mod_hdcp_add_display_to_topology_v3(hdcp, display); 252 else 253 status = mod_hdcp_add_display_to_topology_v2(hdcp, display); 254 255 return status; 256 } 257 #endif 258 enum mod_hdcp_status mod_hdcp_hdcp1_create_session(struct mod_hdcp *hdcp) 259 { 260 261 struct psp_context *psp = hdcp->config.psp.handle; 262 struct mod_hdcp_display *display = get_first_active_display(hdcp); 263 struct ta_hdcp_shared_memory *hdcp_cmd; 264 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 265 266 if (!psp->hdcp_context.hdcp_initialized) { 267 DRM_ERROR("Failed to create hdcp session. HDCP TA is not initialized."); 268 return MOD_HDCP_STATUS_FAILURE; 269 } 270 271 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 272 273 mutex_lock(&psp->hdcp_context.mutex); 274 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 275 276 hdcp_cmd->in_msg.hdcp1_create_session.display_handle = display->index; 277 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_CREATE_SESSION; 278 279 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 280 281 hdcp->auth.id = hdcp_cmd->out_msg.hdcp1_create_session.session_handle; 282 283 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) { 284 status = MOD_HDCP_STATUS_HDCP1_CREATE_SESSION_FAILURE; 285 } else { 286 hdcp->auth.msg.hdcp1.ainfo = hdcp_cmd->out_msg.hdcp1_create_session.ainfo_primary; 287 memcpy(hdcp->auth.msg.hdcp1.aksv, hdcp_cmd->out_msg.hdcp1_create_session.aksv_primary, 288 sizeof(hdcp->auth.msg.hdcp1.aksv)); 289 memcpy(hdcp->auth.msg.hdcp1.an, hdcp_cmd->out_msg.hdcp1_create_session.an_primary, 290 sizeof(hdcp->auth.msg.hdcp1.an)); 291 } 292 293 mutex_unlock(&psp->hdcp_context.mutex); 294 return status; 295 } 296 297 enum mod_hdcp_status mod_hdcp_hdcp1_destroy_session(struct mod_hdcp *hdcp) 298 { 299 300 struct psp_context *psp = hdcp->config.psp.handle; 301 struct ta_hdcp_shared_memory *hdcp_cmd; 302 uint8_t i = 0; 303 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 304 305 mutex_lock(&psp->hdcp_context.mutex); 306 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 307 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 308 309 hdcp_cmd->in_msg.hdcp1_destroy_session.session_handle = hdcp->auth.id; 310 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_DESTROY_SESSION; 311 312 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 313 314 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) { 315 status = MOD_HDCP_STATUS_HDCP1_DESTROY_SESSION_FAILURE; 316 } else { 317 HDCP_TOP_HDCP1_DESTROY_SESSION_TRACE(hdcp); 318 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) 319 if (is_display_encryption_enabled(&hdcp->displays[i])) { 320 hdcp->displays[i].state = 321 MOD_HDCP_DISPLAY_ACTIVE; 322 HDCP_HDCP1_DISABLED_TRACE( 323 hdcp, hdcp->displays[i].index); 324 } 325 } 326 327 mutex_unlock(&psp->hdcp_context.mutex); 328 return status; 329 } 330 331 enum mod_hdcp_status mod_hdcp_hdcp1_validate_rx(struct mod_hdcp *hdcp) 332 { 333 struct psp_context *psp = hdcp->config.psp.handle; 334 struct ta_hdcp_shared_memory *hdcp_cmd; 335 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 336 337 mutex_lock(&psp->hdcp_context.mutex); 338 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 339 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 340 341 hdcp_cmd->in_msg.hdcp1_first_part_authentication.session_handle = hdcp->auth.id; 342 343 memcpy(hdcp_cmd->in_msg.hdcp1_first_part_authentication.bksv_primary, hdcp->auth.msg.hdcp1.bksv, 344 TA_HDCP__HDCP1_KSV_SIZE); 345 346 hdcp_cmd->in_msg.hdcp1_first_part_authentication.r0_prime_primary = hdcp->auth.msg.hdcp1.r0p; 347 hdcp_cmd->in_msg.hdcp1_first_part_authentication.bcaps = hdcp->auth.msg.hdcp1.bcaps; 348 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_FIRST_PART_AUTHENTICATION; 349 350 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 351 352 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) { 353 status = MOD_HDCP_STATUS_HDCP1_VALIDATE_RX_FAILURE; 354 } else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status == 355 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_FIRST_PART_COMPLETE) { 356 /* needs second part of authentication */ 357 hdcp->connection.is_repeater = 1; 358 } else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status == 359 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_AUTHENTICATED) { 360 hdcp->connection.is_repeater = 0; 361 } else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status == 362 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_KSV_REVOKED) { 363 hdcp->connection.is_hdcp1_revoked = 1; 364 status = MOD_HDCP_STATUS_HDCP1_BKSV_REVOKED; 365 } else 366 status = MOD_HDCP_STATUS_HDCP1_VALIDATE_RX_FAILURE; 367 368 mutex_unlock(&psp->hdcp_context.mutex); 369 return status; 370 } 371 372 enum mod_hdcp_status mod_hdcp_hdcp1_enable_encryption(struct mod_hdcp *hdcp) 373 { 374 struct psp_context *psp = hdcp->config.psp.handle; 375 struct ta_hdcp_shared_memory *hdcp_cmd; 376 struct mod_hdcp_display *display = get_first_active_display(hdcp); 377 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 378 379 mutex_lock(&psp->hdcp_context.mutex); 380 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 381 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 382 383 hdcp_cmd->in_msg.hdcp1_enable_encryption.session_handle = hdcp->auth.id; 384 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_ENABLE_ENCRYPTION; 385 386 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 387 388 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) { 389 status = MOD_HDCP_STATUS_HDCP1_ENABLE_ENCRYPTION_FAILURE; 390 } else if (!is_dp_mst_hdcp(hdcp)) { 391 display->state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED; 392 HDCP_HDCP1_ENABLED_TRACE(hdcp, display->index); 393 } 394 395 mutex_unlock(&psp->hdcp_context.mutex); 396 return status; 397 } 398 399 enum mod_hdcp_status mod_hdcp_hdcp1_validate_ksvlist_vp(struct mod_hdcp *hdcp) 400 { 401 struct psp_context *psp = hdcp->config.psp.handle; 402 struct ta_hdcp_shared_memory *hdcp_cmd; 403 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 404 405 mutex_lock(&psp->hdcp_context.mutex); 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.hdcp1_second_part_authentication.session_handle = hdcp->auth.id; 410 411 hdcp_cmd->in_msg.hdcp1_second_part_authentication.ksv_list_size = hdcp->auth.msg.hdcp1.ksvlist_size; 412 memcpy(hdcp_cmd->in_msg.hdcp1_second_part_authentication.ksv_list, hdcp->auth.msg.hdcp1.ksvlist, 413 hdcp->auth.msg.hdcp1.ksvlist_size); 414 415 memcpy(hdcp_cmd->in_msg.hdcp1_second_part_authentication.v_prime, hdcp->auth.msg.hdcp1.vp, 416 sizeof(hdcp->auth.msg.hdcp1.vp)); 417 418 hdcp_cmd->in_msg.hdcp1_second_part_authentication.bstatus_binfo = 419 is_dp_hdcp(hdcp) ? hdcp->auth.msg.hdcp1.binfo_dp : hdcp->auth.msg.hdcp1.bstatus; 420 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_SECOND_PART_AUTHENTICATION; 421 422 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 423 424 if (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS && 425 hdcp_cmd->out_msg.hdcp1_second_part_authentication.authentication_status == 426 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_AUTHENTICATED) { 427 status = MOD_HDCP_STATUS_SUCCESS; 428 } else if (hdcp_cmd->out_msg.hdcp1_second_part_authentication.authentication_status == 429 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_KSV_REVOKED) { 430 hdcp->connection.is_hdcp1_revoked = 1; 431 status = MOD_HDCP_STATUS_HDCP1_KSV_LIST_REVOKED; 432 } else { 433 status = MOD_HDCP_STATUS_HDCP1_VALIDATE_KSV_LIST_FAILURE; 434 } 435 436 mutex_unlock(&psp->hdcp_context.mutex); 437 return status; 438 } 439 440 enum mod_hdcp_status mod_hdcp_hdcp1_enable_dp_stream_encryption(struct mod_hdcp *hdcp) 441 { 442 443 struct psp_context *psp = hdcp->config.psp.handle; 444 struct ta_hdcp_shared_memory *hdcp_cmd; 445 int i = 0; 446 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 447 448 mutex_lock(&psp->hdcp_context.mutex); 449 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 450 451 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) { 452 453 if (hdcp->displays[i].adjust.disable || hdcp->displays[i].state != MOD_HDCP_DISPLAY_ACTIVE) 454 continue; 455 456 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 457 458 hdcp_cmd->in_msg.hdcp1_enable_dp_stream_encryption.session_handle = hdcp->auth.id; 459 hdcp_cmd->in_msg.hdcp1_enable_dp_stream_encryption.display_handle = hdcp->displays[i].index; 460 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_ENABLE_DP_STREAM_ENCRYPTION; 461 462 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 463 464 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) { 465 status = MOD_HDCP_STATUS_HDCP1_ENABLE_STREAM_ENCRYPTION_FAILURE; 466 break; 467 } 468 469 hdcp->displays[i].state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED; 470 HDCP_HDCP1_ENABLED_TRACE(hdcp, hdcp->displays[i].index); 471 } 472 473 mutex_unlock(&psp->hdcp_context.mutex); 474 return status; 475 } 476 477 enum mod_hdcp_status mod_hdcp_hdcp1_link_maintenance(struct mod_hdcp *hdcp) 478 { 479 struct psp_context *psp = hdcp->config.psp.handle; 480 struct ta_hdcp_shared_memory *hdcp_cmd; 481 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 482 483 mutex_lock(&psp->hdcp_context.mutex); 484 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 485 486 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 487 488 hdcp_cmd->in_msg.hdcp1_get_encryption_status.session_handle = hdcp->auth.id; 489 490 hdcp_cmd->out_msg.hdcp1_get_encryption_status.protection_level = 0; 491 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_GET_ENCRYPTION_STATUS; 492 493 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 494 495 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS || 496 hdcp_cmd->out_msg.hdcp1_get_encryption_status.protection_level != 1) 497 status = MOD_HDCP_STATUS_HDCP1_LINK_MAINTENANCE_FAILURE; 498 499 mutex_unlock(&psp->hdcp_context.mutex); 500 return status; 501 } 502 503 enum mod_hdcp_status mod_hdcp_hdcp2_create_session(struct mod_hdcp *hdcp) 504 { 505 struct psp_context *psp = hdcp->config.psp.handle; 506 struct ta_hdcp_shared_memory *hdcp_cmd; 507 struct mod_hdcp_display *display = get_first_active_display(hdcp); 508 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 509 510 511 if (!psp->hdcp_context.hdcp_initialized) { 512 DRM_ERROR("Failed to create hdcp session, HDCP TA is not initialized"); 513 return MOD_HDCP_STATUS_FAILURE; 514 } 515 516 if (!display) 517 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND; 518 519 mutex_lock(&psp->hdcp_context.mutex); 520 521 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 522 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 523 524 hdcp_cmd->in_msg.hdcp2_create_session_v2.display_handle = display->index; 525 526 if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_0) 527 hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type = 528 TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__FORCE_TYPE0; 529 else if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_1) 530 hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type = 531 TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__FORCE_TYPE1; 532 else if (hdcp->connection.link.adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_MAX) 533 hdcp_cmd->in_msg.hdcp2_create_session_v2.negotiate_content_type = 534 TA_HDCP2_CONTENT_TYPE_NEGOTIATION_TYPE__MAX_SUPPORTED; 535 536 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_CREATE_SESSION_V2; 537 538 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 539 540 541 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 542 status = MOD_HDCP_STATUS_HDCP2_CREATE_SESSION_FAILURE; 543 else 544 hdcp->auth.id = hdcp_cmd->out_msg.hdcp2_create_session_v2.session_handle; 545 546 mutex_unlock(&psp->hdcp_context.mutex); 547 return status; 548 } 549 550 enum mod_hdcp_status mod_hdcp_hdcp2_destroy_session(struct mod_hdcp *hdcp) 551 { 552 struct psp_context *psp = hdcp->config.psp.handle; 553 struct ta_hdcp_shared_memory *hdcp_cmd; 554 uint8_t i = 0; 555 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 556 557 mutex_lock(&psp->hdcp_context.mutex); 558 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 559 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 560 561 hdcp_cmd->in_msg.hdcp2_destroy_session.session_handle = hdcp->auth.id; 562 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_DESTROY_SESSION; 563 564 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 565 566 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) { 567 status = MOD_HDCP_STATUS_HDCP2_DESTROY_SESSION_FAILURE; 568 } else { 569 HDCP_TOP_HDCP2_DESTROY_SESSION_TRACE(hdcp); 570 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) 571 if (is_display_encryption_enabled(&hdcp->displays[i])) { 572 hdcp->displays[i].state = 573 MOD_HDCP_DISPLAY_ACTIVE; 574 HDCP_HDCP2_DISABLED_TRACE( 575 hdcp, hdcp->displays[i].index); 576 } 577 } 578 579 mutex_unlock(&psp->hdcp_context.mutex); 580 return status; 581 } 582 583 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_ake_init(struct mod_hdcp *hdcp) 584 { 585 struct psp_context *psp = hdcp->config.psp.handle; 586 struct ta_hdcp_shared_memory *hdcp_cmd; 587 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 588 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; 589 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 590 591 mutex_lock(&psp->hdcp_context.mutex); 592 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 593 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 594 595 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 596 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; 597 598 hdcp2_message_init(hdcp, msg_in); 599 600 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; 601 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__AKE_INIT; 602 603 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 604 605 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 606 status = MOD_HDCP_STATUS_HDCP2_PREP_AKE_INIT_FAILURE; 607 else 608 memcpy(&hdcp->auth.msg.hdcp2.ake_init[0], &msg_out->prepare.transmitter_message[0], 609 sizeof(hdcp->auth.msg.hdcp2.ake_init)); 610 611 mutex_unlock(&psp->hdcp_context.mutex); 612 return status; 613 } 614 615 enum mod_hdcp_status mod_hdcp_hdcp2_validate_ake_cert(struct mod_hdcp *hdcp) 616 { 617 struct psp_context *psp = hdcp->config.psp.handle; 618 struct ta_hdcp_shared_memory *hdcp_cmd; 619 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 620 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; 621 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 622 623 mutex_lock(&psp->hdcp_context.mutex); 624 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 625 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 626 627 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 628 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; 629 630 hdcp2_message_init(hdcp, msg_in); 631 632 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_CERT; 633 msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_CERT; 634 635 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.ake_cert, 636 sizeof(hdcp->auth.msg.hdcp2.ake_cert)); 637 638 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__AKE_NO_STORED_KM; 639 msg_in->prepare.msg2_id = TA_HDCP_HDCP2_MSG_ID__AKE_STORED_KM; 640 641 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; 642 643 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 644 645 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) { 646 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_AKE_CERT_FAILURE; 647 } else { 648 memcpy(hdcp->auth.msg.hdcp2.ake_no_stored_km, 649 &msg_out->prepare.transmitter_message[0], 650 sizeof(hdcp->auth.msg.hdcp2.ake_no_stored_km)); 651 652 memcpy(hdcp->auth.msg.hdcp2.ake_stored_km, 653 &msg_out->prepare.transmitter_message[sizeof(hdcp->auth.msg.hdcp2.ake_no_stored_km)], 654 sizeof(hdcp->auth.msg.hdcp2.ake_stored_km)); 655 656 if (msg_out->process.msg1_status == 657 TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) { 658 hdcp->connection.is_km_stored = 659 msg_out->process.is_km_stored ? 1 : 0; 660 hdcp->connection.is_repeater = 661 msg_out->process.is_repeater ? 1 : 0; 662 status = MOD_HDCP_STATUS_SUCCESS; 663 } else if (msg_out->process.msg1_status == 664 TA_HDCP2_MSG_AUTHENTICATION_STATUS__RECEIVERID_REVOKED) { 665 hdcp->connection.is_hdcp2_revoked = 1; 666 status = MOD_HDCP_STATUS_HDCP2_AKE_CERT_REVOKED; 667 } else { 668 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_AKE_CERT_FAILURE; 669 } 670 } 671 mutex_unlock(&psp->hdcp_context.mutex); 672 return status; 673 } 674 675 enum mod_hdcp_status mod_hdcp_hdcp2_validate_h_prime(struct mod_hdcp *hdcp) 676 { 677 struct psp_context *psp = hdcp->config.psp.handle; 678 struct ta_hdcp_shared_memory *hdcp_cmd; 679 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 680 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; 681 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 682 683 mutex_lock(&psp->hdcp_context.mutex); 684 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 685 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 686 687 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 688 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; 689 690 hdcp2_message_init(hdcp, msg_in); 691 692 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_H_PRIME; 693 msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_H_PRIME; 694 695 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.ake_h_prime, 696 sizeof(hdcp->auth.msg.hdcp2.ake_h_prime)); 697 698 if (!hdcp->connection.is_km_stored) { 699 msg_in->process.msg2_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__AKE_SEND_PAIRING_INFO; 700 msg_in->process.msg2_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__AKE_SEND_PAIRING_INFO; 701 memcpy(&msg_in->process.receiver_message[sizeof(hdcp->auth.msg.hdcp2.ake_h_prime)], 702 hdcp->auth.msg.hdcp2.ake_pairing_info, sizeof(hdcp->auth.msg.hdcp2.ake_pairing_info)); 703 } 704 705 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; 706 707 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 708 709 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 710 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_H_PRIME_FAILURE; 711 else if (msg_out->process.msg1_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) 712 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_H_PRIME_FAILURE; 713 else if (!hdcp->connection.is_km_stored && 714 msg_out->process.msg2_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) 715 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_PAIRING_INFO_FAILURE; 716 717 mutex_unlock(&psp->hdcp_context.mutex); 718 return status; 719 } 720 721 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_lc_init(struct mod_hdcp *hdcp) 722 { 723 struct psp_context *psp = hdcp->config.psp.handle; 724 struct ta_hdcp_shared_memory *hdcp_cmd; 725 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 726 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; 727 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 728 729 mutex_lock(&psp->hdcp_context.mutex); 730 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 731 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 732 733 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 734 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; 735 736 hdcp2_message_init(hdcp, msg_in); 737 738 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__LC_INIT; 739 740 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; 741 742 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 743 744 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 745 status = MOD_HDCP_STATUS_HDCP2_PREP_LC_INIT_FAILURE; 746 else 747 memcpy(hdcp->auth.msg.hdcp2.lc_init, &msg_out->prepare.transmitter_message[0], 748 sizeof(hdcp->auth.msg.hdcp2.lc_init)); 749 750 mutex_unlock(&psp->hdcp_context.mutex); 751 return status; 752 } 753 754 enum mod_hdcp_status mod_hdcp_hdcp2_validate_l_prime(struct mod_hdcp *hdcp) 755 { 756 struct psp_context *psp = hdcp->config.psp.handle; 757 struct ta_hdcp_shared_memory *hdcp_cmd; 758 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 759 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; 760 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 761 762 mutex_lock(&psp->hdcp_context.mutex); 763 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 764 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 765 766 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 767 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; 768 769 hdcp2_message_init(hdcp, msg_in); 770 771 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__LC_SEND_L_PRIME; 772 msg_in->process.msg1_desc.msg_size = TA_HDCP_HDCP2_MSG_ID_MAX_SIZE__LC_SEND_L_PRIME; 773 774 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.lc_l_prime, 775 sizeof(hdcp->auth.msg.hdcp2.lc_l_prime)); 776 777 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; 778 779 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 780 781 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS || 782 msg_out->process.msg1_status != TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) 783 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_L_PRIME_FAILURE; 784 785 mutex_unlock(&psp->hdcp_context.mutex); 786 return status; 787 } 788 789 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_eks(struct mod_hdcp *hdcp) 790 { 791 struct psp_context *psp = hdcp->config.psp.handle; 792 struct ta_hdcp_shared_memory *hdcp_cmd; 793 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 794 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; 795 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 796 797 mutex_lock(&psp->hdcp_context.mutex); 798 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 799 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 800 801 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 802 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; 803 804 hdcp2_message_init(hdcp, msg_in); 805 806 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__SKE_SEND_EKS; 807 808 if (is_dp_hdcp(hdcp)) 809 msg_in->prepare.msg2_id = TA_HDCP_HDCP2_MSG_ID__SIGNAL_CONTENT_STREAM_TYPE_DP; 810 811 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; 812 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 813 814 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) { 815 status = MOD_HDCP_STATUS_HDCP2_PREP_EKS_FAILURE; 816 } else { 817 memcpy(hdcp->auth.msg.hdcp2.ske_eks, 818 &msg_out->prepare.transmitter_message[0], 819 sizeof(hdcp->auth.msg.hdcp2.ske_eks)); 820 msg_out->prepare.msg1_desc.msg_size = 821 sizeof(hdcp->auth.msg.hdcp2.ske_eks); 822 823 if (is_dp_hdcp(hdcp)) { 824 memcpy(hdcp->auth.msg.hdcp2.content_stream_type_dp, 825 &msg_out->prepare.transmitter_message[sizeof(hdcp->auth.msg.hdcp2.ske_eks)], 826 sizeof(hdcp->auth.msg.hdcp2.content_stream_type_dp)); 827 } 828 } 829 mutex_unlock(&psp->hdcp_context.mutex); 830 831 return status; 832 } 833 834 enum mod_hdcp_status mod_hdcp_hdcp2_enable_encryption(struct mod_hdcp *hdcp) 835 { 836 struct psp_context *psp = hdcp->config.psp.handle; 837 struct ta_hdcp_shared_memory *hdcp_cmd; 838 struct mod_hdcp_display *display = get_first_active_display(hdcp); 839 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 840 841 if (!display) 842 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND; 843 844 mutex_lock(&psp->hdcp_context.mutex); 845 846 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 847 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 848 849 hdcp_cmd->in_msg.hdcp2_set_encryption.session_handle = hdcp->auth.id; 850 851 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_SET_ENCRYPTION; 852 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 853 854 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) { 855 status = MOD_HDCP_STATUS_HDCP2_ENABLE_ENCRYPTION_FAILURE; 856 } else if (!is_dp_mst_hdcp(hdcp)) { 857 display->state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED; 858 HDCP_HDCP2_ENABLED_TRACE(hdcp, display->index); 859 } 860 861 mutex_unlock(&psp->hdcp_context.mutex); 862 return status; 863 } 864 865 enum mod_hdcp_status mod_hdcp_hdcp2_validate_rx_id_list(struct mod_hdcp *hdcp) 866 { 867 struct psp_context *psp = hdcp->config.psp.handle; 868 struct ta_hdcp_shared_memory *hdcp_cmd; 869 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 870 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; 871 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 872 873 mutex_lock(&psp->hdcp_context.mutex); 874 875 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 876 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 877 878 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 879 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; 880 881 hdcp2_message_init(hdcp, msg_in); 882 883 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_SEND_RECEIVERID_LIST; 884 msg_in->process.msg1_desc.msg_size = sizeof(hdcp->auth.msg.hdcp2.rx_id_list); 885 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.rx_id_list, 886 sizeof(hdcp->auth.msg.hdcp2.rx_id_list)); 887 888 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_SEND_ACK; 889 890 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; 891 892 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 893 894 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) { 895 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_RX_ID_LIST_FAILURE; 896 } else { 897 memcpy(hdcp->auth.msg.hdcp2.repeater_auth_ack, 898 &msg_out->prepare.transmitter_message[0], 899 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_ack)); 900 901 if (msg_out->process.msg1_status == 902 TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) { 903 hdcp->connection.is_km_stored = msg_out->process.is_km_stored ? 1 : 0; 904 hdcp->connection.is_repeater = msg_out->process.is_repeater ? 1 : 0; 905 status = MOD_HDCP_STATUS_SUCCESS; 906 } else if (msg_out->process.msg1_status == 907 TA_HDCP2_MSG_AUTHENTICATION_STATUS__RECEIVERID_REVOKED) { 908 hdcp->connection.is_hdcp2_revoked = 1; 909 status = MOD_HDCP_STATUS_HDCP2_RX_ID_LIST_REVOKED; 910 } else { 911 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_RX_ID_LIST_FAILURE; 912 } 913 } 914 mutex_unlock(&psp->hdcp_context.mutex); 915 return status; 916 } 917 918 enum mod_hdcp_status mod_hdcp_hdcp2_enable_dp_stream_encryption(struct mod_hdcp *hdcp) 919 { 920 struct psp_context *psp = hdcp->config.psp.handle; 921 struct ta_hdcp_shared_memory *hdcp_cmd; 922 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 923 uint8_t i; 924 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 925 926 mutex_lock(&psp->hdcp_context.mutex); 927 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 928 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 929 930 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 931 932 hdcp2_message_init(hdcp, msg_in); 933 934 935 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) { 936 if (hdcp->displays[i].adjust.disable || hdcp->displays[i].state != MOD_HDCP_DISPLAY_ACTIVE) 937 continue; 938 939 hdcp_cmd->in_msg.hdcp2_enable_dp_stream_encryption.display_handle = hdcp->displays[i].index; 940 hdcp_cmd->in_msg.hdcp2_enable_dp_stream_encryption.session_handle = hdcp->auth.id; 941 942 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_ENABLE_DP_STREAM_ENCRYPTION; 943 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 944 945 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) 946 break; 947 948 hdcp->displays[i].state = MOD_HDCP_DISPLAY_ENCRYPTION_ENABLED; 949 HDCP_HDCP2_ENABLED_TRACE(hdcp, hdcp->displays[i].index); 950 } 951 952 if (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS) 953 status = MOD_HDCP_STATUS_SUCCESS; 954 else 955 status = MOD_HDCP_STATUS_HDCP2_ENABLE_STREAM_ENCRYPTION_FAILURE; 956 957 mutex_unlock(&psp->hdcp_context.mutex); 958 return status; 959 } 960 961 enum mod_hdcp_status mod_hdcp_hdcp2_prepare_stream_management(struct mod_hdcp *hdcp) 962 { 963 964 struct psp_context *psp = hdcp->config.psp.handle; 965 struct ta_hdcp_shared_memory *hdcp_cmd; 966 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 967 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; 968 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 969 970 mutex_lock(&psp->hdcp_context.mutex); 971 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 972 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 973 974 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 975 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; 976 977 hdcp2_message_init(hdcp, msg_in); 978 979 msg_in->prepare.msg1_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_STREAM_MANAGE; 980 981 982 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; 983 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 984 985 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) { 986 status = MOD_HDCP_STATUS_HDCP2_PREPARE_STREAM_MANAGEMENT_FAILURE; 987 } else { 988 hdcp->auth.msg.hdcp2.stream_manage_size = msg_out->prepare.msg1_desc.msg_size; 989 990 memcpy(hdcp->auth.msg.hdcp2.repeater_auth_stream_manage, 991 &msg_out->prepare.transmitter_message[0], 992 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_manage)); 993 } 994 mutex_unlock(&psp->hdcp_context.mutex); 995 return status; 996 } 997 998 enum mod_hdcp_status mod_hdcp_hdcp2_validate_stream_ready(struct mod_hdcp *hdcp) 999 { 1000 struct psp_context *psp = hdcp->config.psp.handle; 1001 struct ta_hdcp_shared_memory *hdcp_cmd; 1002 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_input_v2 *msg_in; 1003 struct ta_hdcp_cmd_hdcp2_process_prepare_authentication_message_output_v2 *msg_out; 1004 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 1005 1006 mutex_lock(&psp->hdcp_context.mutex); 1007 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.hdcp_shared_buf; 1008 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 1009 1010 msg_in = &hdcp_cmd->in_msg.hdcp2_prepare_process_authentication_message_v2; 1011 msg_out = &hdcp_cmd->out_msg.hdcp2_prepare_process_authentication_message_v2; 1012 1013 hdcp2_message_init(hdcp, msg_in); 1014 1015 msg_in->process.msg1_desc.msg_id = TA_HDCP_HDCP2_MSG_ID__REPEATERAUTH_STREAM_READY; 1016 1017 msg_in->process.msg1_desc.msg_size = sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_ready); 1018 1019 memcpy(&msg_in->process.receiver_message[0], hdcp->auth.msg.hdcp2.repeater_auth_stream_ready, 1020 sizeof(hdcp->auth.msg.hdcp2.repeater_auth_stream_ready)); 1021 1022 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP2_PREPARE_PROCESS_AUTHENTICATION_MSG_V2; 1023 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 1024 1025 if (hdcp_cmd->hdcp_status == TA_HDCP_STATUS__SUCCESS && 1026 msg_out->process.msg1_status == TA_HDCP2_MSG_AUTHENTICATION_STATUS__SUCCESS) 1027 status = MOD_HDCP_STATUS_SUCCESS; 1028 else 1029 status = MOD_HDCP_STATUS_HDCP2_VALIDATE_STREAM_READY_FAILURE; 1030 1031 mutex_unlock(&psp->hdcp_context.mutex); 1032 return status; 1033 } 1034 1035 bool mod_hdcp_is_link_encryption_enabled(struct mod_hdcp *hdcp) 1036 { 1037 /* unsupported */ 1038 return true; 1039 } 1040 1041 void mod_hdcp_save_current_encryption_states(struct mod_hdcp *hdcp) 1042 { 1043 /* unsupported */ 1044 } 1045