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