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