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 48 static enum mod_hdcp_status remove_display_from_topology_v2( 49 struct mod_hdcp *hdcp, uint8_t index) 50 { 51 struct psp_context *psp = hdcp->config.psp.handle; 52 struct ta_dtm_shared_memory *dtm_cmd; 53 struct mod_hdcp_display *display = 54 get_active_display_at_index(hdcp, index); 55 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 56 57 dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.context.mem_context.shared_buf; 58 59 if (!display || !is_display_active(display)) 60 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND; 61 62 mutex_lock(&psp->dtm_context.mutex); 63 64 memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory)); 65 66 dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V2; 67 dtm_cmd->dtm_in_message.topology_update_v2.display_handle = display->index; 68 dtm_cmd->dtm_in_message.topology_update_v2.is_active = 0; 69 dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE; 70 71 psp_dtm_invoke(psp, dtm_cmd->cmd_id); 72 73 if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) { 74 status = MOD_HDCP_STATUS_UPDATE_TOPOLOGY_FAILURE; 75 } else { 76 display->state = MOD_HDCP_DISPLAY_ACTIVE; 77 HDCP_TOP_REMOVE_DISPLAY_TRACE(hdcp, display->index); 78 } 79 80 mutex_unlock(&psp->dtm_context.mutex); 81 return status; 82 } 83 84 static enum mod_hdcp_status remove_display_from_topology_v3( 85 struct mod_hdcp *hdcp, uint8_t index) 86 { 87 struct psp_context *psp = hdcp->config.psp.handle; 88 struct ta_dtm_shared_memory *dtm_cmd; 89 struct mod_hdcp_display *display = 90 get_active_display_at_index(hdcp, index); 91 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 92 93 dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.context.mem_context.shared_buf; 94 95 if (!display || !is_display_active(display)) 96 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND; 97 98 mutex_lock(&psp->dtm_context.mutex); 99 100 memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory)); 101 102 dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V3; 103 dtm_cmd->dtm_in_message.topology_update_v3.display_handle = display->index; 104 dtm_cmd->dtm_in_message.topology_update_v3.is_active = 0; 105 dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE; 106 107 psp_dtm_invoke(psp, dtm_cmd->cmd_id); 108 mutex_unlock(&psp->dtm_context.mutex); 109 110 if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) { 111 status = remove_display_from_topology_v2(hdcp, index); 112 if (status != MOD_HDCP_STATUS_SUCCESS) 113 display->state = MOD_HDCP_DISPLAY_INACTIVE; 114 } else { 115 display->state = MOD_HDCP_DISPLAY_ACTIVE; 116 HDCP_TOP_REMOVE_DISPLAY_TRACE(hdcp, display->index); 117 } 118 119 return status; 120 } 121 122 static enum mod_hdcp_status add_display_to_topology_v2( 123 struct mod_hdcp *hdcp, struct mod_hdcp_display *display) 124 { 125 struct psp_context *psp = hdcp->config.psp.handle; 126 struct ta_dtm_shared_memory *dtm_cmd; 127 struct mod_hdcp_link *link = &hdcp->connection.link; 128 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 129 130 if (!psp->dtm_context.context.initialized) { 131 DRM_INFO("Failed to add display topology, DTM TA is not initialized."); 132 display->state = MOD_HDCP_DISPLAY_INACTIVE; 133 return MOD_HDCP_STATUS_FAILURE; 134 } 135 136 dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.context.mem_context.shared_buf; 137 138 mutex_lock(&psp->dtm_context.mutex); 139 memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory)); 140 141 dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V2; 142 dtm_cmd->dtm_in_message.topology_update_v2.display_handle = display->index; 143 dtm_cmd->dtm_in_message.topology_update_v2.is_active = 1; 144 dtm_cmd->dtm_in_message.topology_update_v2.controller = display->controller; 145 dtm_cmd->dtm_in_message.topology_update_v2.ddc_line = link->ddc_line; 146 dtm_cmd->dtm_in_message.topology_update_v2.dig_be = link->dig_be; 147 dtm_cmd->dtm_in_message.topology_update_v2.dig_fe = display->dig_fe; 148 if (is_dp_hdcp(hdcp)) 149 dtm_cmd->dtm_in_message.topology_update_v2.is_assr = link->dp.assr_enabled; 150 151 dtm_cmd->dtm_in_message.topology_update_v2.dp_mst_vcid = display->vc_id; 152 dtm_cmd->dtm_in_message.topology_update_v2.max_hdcp_supported_version = 153 TA_DTM_HDCP_VERSION_MAX_SUPPORTED__2_2; 154 dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE; 155 156 psp_dtm_invoke(psp, dtm_cmd->cmd_id); 157 158 if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) { 159 display->state = MOD_HDCP_DISPLAY_INACTIVE; 160 status = MOD_HDCP_STATUS_UPDATE_TOPOLOGY_FAILURE; 161 } else { 162 HDCP_TOP_ADD_DISPLAY_TRACE(hdcp, display->index); 163 } 164 165 mutex_unlock(&psp->dtm_context.mutex); 166 return status; 167 } 168 169 static enum mod_hdcp_status add_display_to_topology_v3( 170 struct mod_hdcp *hdcp, struct mod_hdcp_display *display) 171 { 172 struct psp_context *psp = hdcp->config.psp.handle; 173 struct ta_dtm_shared_memory *dtm_cmd; 174 struct mod_hdcp_link *link = &hdcp->connection.link; 175 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 176 177 if (!psp->dtm_context.context.initialized) { 178 DRM_INFO("Failed to add display topology, DTM TA is not initialized."); 179 display->state = MOD_HDCP_DISPLAY_INACTIVE; 180 return MOD_HDCP_STATUS_FAILURE; 181 } 182 183 dtm_cmd = (struct ta_dtm_shared_memory *)psp->dtm_context.context.mem_context.shared_buf; 184 185 mutex_lock(&psp->dtm_context.mutex); 186 memset(dtm_cmd, 0, sizeof(struct ta_dtm_shared_memory)); 187 188 dtm_cmd->cmd_id = TA_DTM_COMMAND__TOPOLOGY_UPDATE_V3; 189 dtm_cmd->dtm_in_message.topology_update_v3.display_handle = display->index; 190 dtm_cmd->dtm_in_message.topology_update_v3.is_active = 1; 191 dtm_cmd->dtm_in_message.topology_update_v3.controller = display->controller; 192 dtm_cmd->dtm_in_message.topology_update_v3.ddc_line = link->ddc_line; 193 dtm_cmd->dtm_in_message.topology_update_v3.link_enc = link->link_enc_idx; 194 dtm_cmd->dtm_in_message.topology_update_v3.stream_enc = display->stream_enc_idx; 195 if (is_dp_hdcp(hdcp)) 196 dtm_cmd->dtm_in_message.topology_update_v3.is_assr = link->dp.assr_enabled; 197 198 dtm_cmd->dtm_in_message.topology_update_v3.dp_mst_vcid = display->vc_id; 199 dtm_cmd->dtm_in_message.topology_update_v3.max_hdcp_supported_version = 200 TA_DTM_HDCP_VERSION_MAX_SUPPORTED__2_3; 201 dtm_cmd->dtm_in_message.topology_update_v3.encoder_type = TA_DTM_ENCODER_TYPE__DIG; 202 dtm_cmd->dtm_status = TA_DTM_STATUS__GENERIC_FAILURE; 203 if (is_frl_hdcp(hdcp)) 204 dtm_cmd->dtm_in_message.topology_update_v3.encoder_type = TA_DTM_ENCODER_TYPE__FRL; 205 dtm_cmd->dtm_in_message.topology_update_v3.phy_id = link->phy_idx; 206 dtm_cmd->dtm_in_message.topology_update_v3.link_hdcp_cap = link->hdcp_supported_informational; 207 dtm_cmd->dtm_in_message.topology_update_v3.dio_output_type = link->dp.usb4_enabled ? 208 TA_DTM_DIO_OUTPUT_TYPE__DPIA : 209 TA_DTM_DIO_OUTPUT_TYPE__DIRECT; 210 dtm_cmd->dtm_in_message.topology_update_v3.dio_output_id = link->dio_output_id; 211 212 psp_dtm_invoke(psp, dtm_cmd->cmd_id); 213 mutex_unlock(&psp->dtm_context.mutex); 214 215 if (dtm_cmd->dtm_status != TA_DTM_STATUS__SUCCESS) { 216 status = add_display_to_topology_v2(hdcp, display); 217 if (status != MOD_HDCP_STATUS_SUCCESS) 218 display->state = MOD_HDCP_DISPLAY_INACTIVE; 219 } else { 220 HDCP_TOP_ADD_DISPLAY_TRACE(hdcp, display->index); 221 } 222 223 return status; 224 } 225 226 enum mod_hdcp_status mod_hdcp_remove_display_from_topology( 227 struct mod_hdcp *hdcp, uint8_t index) 228 { 229 enum mod_hdcp_status status = MOD_HDCP_STATUS_UPDATE_TOPOLOGY_FAILURE; 230 231 if (hdcp->config.psp.caps.dtm_v3_supported) 232 status = remove_display_from_topology_v3(hdcp, index); 233 else 234 status = remove_display_from_topology_v2(hdcp, index); 235 236 return status; 237 } 238 239 enum mod_hdcp_status mod_hdcp_add_display_to_topology(struct mod_hdcp *hdcp, 240 struct mod_hdcp_display *display) 241 { 242 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 243 244 if (hdcp->config.psp.caps.dtm_v3_supported) 245 status = add_display_to_topology_v3(hdcp, display); 246 else 247 status = add_display_to_topology_v2(hdcp, display); 248 249 return status; 250 } 251 252 enum mod_hdcp_status mod_hdcp_hdcp1_create_session(struct mod_hdcp *hdcp) 253 { 254 255 struct psp_context *psp = hdcp->config.psp.handle; 256 struct mod_hdcp_display *display = get_first_active_display(hdcp); 257 struct ta_hdcp_shared_memory *hdcp_cmd; 258 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 259 260 if (!psp->hdcp_context.context.initialized) { 261 DRM_ERROR("Failed to create hdcp session. HDCP TA is not initialized."); 262 return MOD_HDCP_STATUS_FAILURE; 263 } 264 265 if (!display) 266 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND; 267 268 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf; 269 270 mutex_lock(&psp->hdcp_context.mutex); 271 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 272 273 hdcp_cmd->in_msg.hdcp1_create_session.display_handle = display->index; 274 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_CREATE_SESSION; 275 276 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 277 278 hdcp->auth.id = hdcp_cmd->out_msg.hdcp1_create_session.session_handle; 279 280 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) { 281 status = MOD_HDCP_STATUS_HDCP1_CREATE_SESSION_FAILURE; 282 } else { 283 hdcp->auth.msg.hdcp1.ainfo = hdcp_cmd->out_msg.hdcp1_create_session.ainfo_primary; 284 memcpy(hdcp->auth.msg.hdcp1.aksv, hdcp_cmd->out_msg.hdcp1_create_session.aksv_primary, 285 sizeof(hdcp->auth.msg.hdcp1.aksv)); 286 memcpy(hdcp->auth.msg.hdcp1.an, hdcp_cmd->out_msg.hdcp1_create_session.an_primary, 287 sizeof(hdcp->auth.msg.hdcp1.an)); 288 } 289 290 mutex_unlock(&psp->hdcp_context.mutex); 291 return status; 292 } 293 294 enum mod_hdcp_status mod_hdcp_hdcp1_destroy_session(struct mod_hdcp *hdcp) 295 { 296 297 struct psp_context *psp = hdcp->config.psp.handle; 298 struct ta_hdcp_shared_memory *hdcp_cmd; 299 uint8_t i = 0; 300 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 301 302 mutex_lock(&psp->hdcp_context.mutex); 303 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf; 304 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 305 306 hdcp_cmd->in_msg.hdcp1_destroy_session.session_handle = hdcp->auth.id; 307 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_DESTROY_SESSION; 308 309 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 310 311 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) { 312 status = MOD_HDCP_STATUS_HDCP1_DESTROY_SESSION_FAILURE; 313 } else { 314 HDCP_TOP_HDCP1_DESTROY_SESSION_TRACE(hdcp); 315 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) 316 if (is_display_encryption_enabled(&hdcp->displays[i])) { 317 hdcp->displays[i].state = 318 MOD_HDCP_DISPLAY_ACTIVE; 319 HDCP_HDCP1_DISABLED_TRACE( 320 hdcp, hdcp->displays[i].index); 321 } 322 } 323 324 mutex_unlock(&psp->hdcp_context.mutex); 325 return status; 326 } 327 328 enum mod_hdcp_status mod_hdcp_hdcp1_validate_rx(struct mod_hdcp *hdcp) 329 { 330 struct psp_context *psp = hdcp->config.psp.handle; 331 struct ta_hdcp_shared_memory *hdcp_cmd; 332 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 333 334 mutex_lock(&psp->hdcp_context.mutex); 335 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.shared_buf; 336 memset(hdcp_cmd, 0, sizeof(struct ta_hdcp_shared_memory)); 337 338 hdcp_cmd->in_msg.hdcp1_first_part_authentication.session_handle = hdcp->auth.id; 339 340 memcpy(hdcp_cmd->in_msg.hdcp1_first_part_authentication.bksv_primary, hdcp->auth.msg.hdcp1.bksv, 341 TA_HDCP__HDCP1_KSV_SIZE); 342 343 hdcp_cmd->in_msg.hdcp1_first_part_authentication.r0_prime_primary = hdcp->auth.msg.hdcp1.r0p; 344 hdcp_cmd->in_msg.hdcp1_first_part_authentication.bcaps = hdcp->auth.msg.hdcp1.bcaps; 345 hdcp_cmd->cmd_id = TA_HDCP_COMMAND__HDCP1_FIRST_PART_AUTHENTICATION; 346 347 psp_hdcp_invoke(psp, hdcp_cmd->cmd_id); 348 349 if (hdcp_cmd->hdcp_status != TA_HDCP_STATUS__SUCCESS) { 350 status = MOD_HDCP_STATUS_HDCP1_VALIDATE_RX_FAILURE; 351 } else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status == 352 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_FIRST_PART_COMPLETE) { 353 /* needs second part of authentication */ 354 hdcp->connection.is_repeater = 1; 355 } else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status == 356 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_AUTHENTICATED) { 357 hdcp->connection.is_repeater = 0; 358 } else if (hdcp_cmd->out_msg.hdcp1_first_part_authentication.authentication_status == 359 TA_HDCP_AUTHENTICATION_STATUS__HDCP1_KSV_REVOKED) { 360 hdcp->connection.is_hdcp1_revoked = 1; 361 status = MOD_HDCP_STATUS_HDCP1_BKSV_REVOKED; 362 } else 363 status = MOD_HDCP_STATUS_HDCP1_VALIDATE_RX_FAILURE; 364 365 mutex_unlock(&psp->hdcp_context.mutex); 366 return status; 367 } 368 369 enum mod_hdcp_status mod_hdcp_hdcp1_enable_encryption(struct mod_hdcp *hdcp) 370 { 371 struct psp_context *psp = hdcp->config.psp.handle; 372 struct ta_hdcp_shared_memory *hdcp_cmd; 373 struct mod_hdcp_display *display = get_first_active_display(hdcp); 374 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 375 376 if (!display) 377 return MOD_HDCP_STATUS_DISPLAY_NOT_FOUND; 378 379 mutex_lock(&psp->hdcp_context.mutex); 380 hdcp_cmd = (struct ta_hdcp_shared_memory *)psp->hdcp_context.context.mem_context.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.context.mem_context.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.context.mem_context.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.context.mem_context.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.context.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.context.mem_context.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.context.mem_context.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.context.mem_context.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.context.mem_context.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.context.mem_context.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.context.mem_context.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.context.mem_context.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.context.mem_context.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.context.mem_context.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.context.mem_context.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.context.mem_context.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.context.mem_context.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.context.mem_context.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