1 /* 2 * Copyright 2019 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 #include "hdcp.h" 27 28 static void push_error_status(struct mod_hdcp *hdcp, 29 enum mod_hdcp_status status) 30 { 31 struct mod_hdcp_trace *trace = &hdcp->connection.trace; 32 33 if (trace->error_count < MAX_NUM_OF_ERROR_TRACE) { 34 trace->errors[trace->error_count].status = status; 35 trace->errors[trace->error_count].state_id = hdcp->state.id; 36 trace->error_count++; 37 HDCP_ERROR_TRACE(hdcp, status); 38 } 39 40 if (is_hdcp1(hdcp)) { 41 hdcp->connection.hdcp1_retry_count++; 42 if (hdcp->connection.hdcp1_retry_count == MAX_NUM_OF_ATTEMPTS) 43 hdcp->connection.link.adjust.hdcp1.disable = 1; 44 } else if (is_hdcp2(hdcp)) { 45 hdcp->connection.hdcp2_retry_count++; 46 if (hdcp->connection.hdcp2_retry_count == MAX_NUM_OF_ATTEMPTS) 47 hdcp->connection.link.adjust.hdcp2.disable = 1; 48 } 49 } 50 51 static uint8_t is_cp_desired_hdcp1(struct mod_hdcp *hdcp) 52 { 53 int i, is_auth_needed = 0; 54 55 /* if all displays on the link don't need authentication, 56 * hdcp is not desired 57 */ 58 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) { 59 if (hdcp->displays[i].state != MOD_HDCP_DISPLAY_INACTIVE && 60 hdcp->displays[i].adjust.disable != MOD_HDCP_DISPLAY_DISABLE_AUTHENTICATION) { 61 is_auth_needed = 1; 62 break; 63 } 64 } 65 66 return is_auth_needed && 67 !hdcp->connection.link.adjust.hdcp1.disable && 68 !hdcp->connection.is_hdcp1_revoked; 69 } 70 71 static uint8_t is_cp_desired_hdcp2(struct mod_hdcp *hdcp) 72 { 73 int i, is_auth_needed = 0; 74 75 /* if all displays on the link don't need authentication, 76 * hdcp is not desired 77 */ 78 for (i = 0; i < MAX_NUM_OF_DISPLAYS; i++) { 79 if (hdcp->displays[i].state != MOD_HDCP_DISPLAY_INACTIVE && 80 hdcp->displays[i].adjust.disable != MOD_HDCP_DISPLAY_DISABLE_AUTHENTICATION) { 81 is_auth_needed = 1; 82 break; 83 } 84 } 85 86 return is_auth_needed && 87 !hdcp->connection.link.adjust.hdcp2.disable && 88 !hdcp->connection.is_hdcp2_revoked; 89 } 90 91 static void exit_idle_optimizations(struct mod_hdcp *hdcp) 92 { 93 struct mod_hdcp_dm *dm = &hdcp->config.dm; 94 95 if (dm->funcs.exit_idle_optimizations) 96 dm->funcs.exit_idle_optimizations(dm->handle); 97 } 98 99 static enum mod_hdcp_status execution(struct mod_hdcp *hdcp, 100 struct mod_hdcp_event_context *event_ctx, 101 union mod_hdcp_transition_input *input) 102 { 103 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 104 105 if (is_in_initialized_state(hdcp)) { 106 if (event_ctx->event != MOD_HDCP_EVENT_CALLBACK) { 107 event_ctx->unexpected_event = 1; 108 goto out; 109 } 110 /* initialize transition input */ 111 memset(input, 0, sizeof(union mod_hdcp_transition_input)); 112 } else if (is_in_cp_not_desired_state(hdcp)) { 113 if (event_ctx->event != MOD_HDCP_EVENT_CALLBACK) { 114 event_ctx->unexpected_event = 1; 115 goto out; 116 } 117 } else if (is_in_hdcp1_states(hdcp)) { 118 status = mod_hdcp_hdcp1_execution(hdcp, event_ctx, &input->hdcp1); 119 } else if (is_in_hdcp1_dp_states(hdcp)) { 120 status = mod_hdcp_hdcp1_dp_execution(hdcp, 121 event_ctx, &input->hdcp1); 122 } else if (is_in_hdcp2_states(hdcp)) { 123 status = mod_hdcp_hdcp2_execution(hdcp, event_ctx, &input->hdcp2); 124 } else if (is_in_hdcp2_dp_states(hdcp)) { 125 status = mod_hdcp_hdcp2_dp_execution(hdcp, 126 event_ctx, &input->hdcp2); 127 } else { 128 event_ctx->unexpected_event = 1; 129 goto out; 130 } 131 out: 132 return status; 133 } 134 135 static enum mod_hdcp_status transition(struct mod_hdcp *hdcp, 136 struct mod_hdcp_event_context *event_ctx, 137 union mod_hdcp_transition_input *input, 138 struct mod_hdcp_output *output) 139 { 140 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 141 142 if (event_ctx->unexpected_event) 143 goto out; 144 145 if (is_in_initialized_state(hdcp)) { 146 if (is_dp_hdcp(hdcp)) 147 if (is_cp_desired_hdcp2(hdcp)) { 148 callback_in_ms(0, output); 149 set_state_id(hdcp, output, D2_A0_DETERMINE_RX_HDCP_CAPABLE); 150 } else if (is_cp_desired_hdcp1(hdcp)) { 151 callback_in_ms(0, output); 152 set_state_id(hdcp, output, D1_A0_DETERMINE_RX_HDCP_CAPABLE); 153 } else { 154 callback_in_ms(0, output); 155 set_state_id(hdcp, output, HDCP_CP_NOT_DESIRED); 156 set_auth_complete(hdcp, output); 157 } 158 else if (is_hdmi_dvi_sl_hdcp(hdcp)) 159 if (is_cp_desired_hdcp2(hdcp)) { 160 callback_in_ms(0, output); 161 set_state_id(hdcp, output, H2_A0_KNOWN_HDCP2_CAPABLE_RX); 162 } else if (is_cp_desired_hdcp1(hdcp)) { 163 callback_in_ms(0, output); 164 set_state_id(hdcp, output, H1_A0_WAIT_FOR_ACTIVE_RX); 165 } else { 166 callback_in_ms(0, output); 167 set_state_id(hdcp, output, HDCP_CP_NOT_DESIRED); 168 set_auth_complete(hdcp, output); 169 } 170 else { 171 callback_in_ms(0, output); 172 set_state_id(hdcp, output, HDCP_CP_NOT_DESIRED); 173 set_auth_complete(hdcp, output); 174 } 175 } else if (is_in_cp_not_desired_state(hdcp)) { 176 increment_stay_counter(hdcp); 177 } else if (is_in_hdcp1_states(hdcp)) { 178 status = mod_hdcp_hdcp1_transition(hdcp, 179 event_ctx, &input->hdcp1, output); 180 } else if (is_in_hdcp1_dp_states(hdcp)) { 181 status = mod_hdcp_hdcp1_dp_transition(hdcp, 182 event_ctx, &input->hdcp1, output); 183 } else if (is_in_hdcp2_states(hdcp)) { 184 status = mod_hdcp_hdcp2_transition(hdcp, 185 event_ctx, &input->hdcp2, output); 186 } else if (is_in_hdcp2_dp_states(hdcp)) { 187 status = mod_hdcp_hdcp2_dp_transition(hdcp, 188 event_ctx, &input->hdcp2, output); 189 } else { 190 status = MOD_HDCP_STATUS_INVALID_STATE; 191 } 192 out: 193 return status; 194 } 195 196 static enum mod_hdcp_status reset_authentication(struct mod_hdcp *hdcp, 197 struct mod_hdcp_output *output) 198 { 199 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 200 201 if (is_hdcp1(hdcp)) { 202 if (hdcp->auth.trans_input.hdcp1.create_session != UNKNOWN) { 203 /* TODO - update psp to unify create session failure 204 * recovery between hdcp1 and 2. 205 */ 206 mod_hdcp_hdcp1_destroy_session(hdcp); 207 208 } 209 210 HDCP_TOP_RESET_AUTH_TRACE(hdcp); 211 memset(&hdcp->auth, 0, sizeof(struct mod_hdcp_authentication)); 212 memset(&hdcp->state, 0, sizeof(struct mod_hdcp_state)); 213 set_state_id(hdcp, output, HDCP_INITIALIZED); 214 } else if (is_hdcp2(hdcp)) { 215 if (hdcp->auth.trans_input.hdcp2.create_session == PASS) { 216 status = mod_hdcp_hdcp2_destroy_session(hdcp); 217 if (status != MOD_HDCP_STATUS_SUCCESS) { 218 output->callback_needed = 0; 219 output->watchdog_timer_needed = 0; 220 goto out; 221 } 222 } 223 224 HDCP_TOP_RESET_AUTH_TRACE(hdcp); 225 memset(&hdcp->auth, 0, sizeof(struct mod_hdcp_authentication)); 226 memset(&hdcp->state, 0, sizeof(struct mod_hdcp_state)); 227 set_state_id(hdcp, output, HDCP_INITIALIZED); 228 } else if (is_in_cp_not_desired_state(hdcp)) { 229 HDCP_TOP_RESET_AUTH_TRACE(hdcp); 230 memset(&hdcp->auth, 0, sizeof(struct mod_hdcp_authentication)); 231 memset(&hdcp->state, 0, sizeof(struct mod_hdcp_state)); 232 set_state_id(hdcp, output, HDCP_INITIALIZED); 233 } 234 235 out: 236 /* stop callback and watchdog requests from previous authentication*/ 237 output->watchdog_timer_stop = 1; 238 output->callback_stop = 1; 239 return status; 240 } 241 242 static enum mod_hdcp_status reset_connection(struct mod_hdcp *hdcp, 243 struct mod_hdcp_output *output) 244 { 245 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 246 247 memset(output, 0, sizeof(struct mod_hdcp_output)); 248 249 status = reset_authentication(hdcp, output); 250 if (status != MOD_HDCP_STATUS_SUCCESS) 251 goto out; 252 253 if (current_state(hdcp) != HDCP_UNINITIALIZED) { 254 HDCP_TOP_RESET_CONN_TRACE(hdcp); 255 set_state_id(hdcp, output, HDCP_UNINITIALIZED); 256 } 257 memset(&hdcp->connection, 0, sizeof(hdcp->connection)); 258 out: 259 return status; 260 } 261 262 static enum mod_hdcp_status update_display_adjustments(struct mod_hdcp *hdcp, 263 struct mod_hdcp_display *display, 264 struct mod_hdcp_display_adjustment *adj) 265 { 266 enum mod_hdcp_status status = MOD_HDCP_STATUS_NOT_IMPLEMENTED; 267 268 if (is_in_authenticated_states(hdcp) && 269 is_dp_mst_hdcp(hdcp) && 270 display->adjust.disable == true && 271 adj->disable == false) { 272 display->adjust.disable = false; 273 if (is_hdcp1(hdcp)) 274 status = mod_hdcp_hdcp1_enable_dp_stream_encryption(hdcp); 275 else if (is_hdcp2(hdcp)) 276 status = mod_hdcp_hdcp2_enable_dp_stream_encryption(hdcp); 277 278 if (status != MOD_HDCP_STATUS_SUCCESS) 279 display->adjust.disable = true; 280 } 281 282 if (status == MOD_HDCP_STATUS_SUCCESS && 283 memcmp(adj, &display->adjust, 284 sizeof(struct mod_hdcp_display_adjustment)) != 0) 285 status = MOD_HDCP_STATUS_NOT_IMPLEMENTED; 286 287 return status; 288 } 289 /* 290 * Implementation of functions in mod_hdcp.h 291 */ 292 size_t mod_hdcp_get_memory_size(void) 293 { 294 return sizeof(struct mod_hdcp); 295 } 296 297 enum mod_hdcp_status mod_hdcp_setup(struct mod_hdcp *hdcp, 298 struct mod_hdcp_config *config) 299 { 300 struct mod_hdcp_output output; 301 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 302 303 memset(&output, 0, sizeof(output)); 304 hdcp->config = *config; 305 HDCP_TOP_INTERFACE_TRACE(hdcp); 306 status = reset_connection(hdcp, &output); 307 if (status != MOD_HDCP_STATUS_SUCCESS) 308 push_error_status(hdcp, status); 309 return status; 310 } 311 312 enum mod_hdcp_status mod_hdcp_teardown(struct mod_hdcp *hdcp) 313 { 314 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 315 struct mod_hdcp_output output; 316 317 HDCP_TOP_INTERFACE_TRACE(hdcp); 318 memset(&output, 0, sizeof(output)); 319 status = reset_connection(hdcp, &output); 320 if (status == MOD_HDCP_STATUS_SUCCESS) 321 memset(hdcp, 0, sizeof(struct mod_hdcp)); 322 else 323 push_error_status(hdcp, status); 324 return status; 325 } 326 327 enum mod_hdcp_status mod_hdcp_add_display(struct mod_hdcp *hdcp, 328 struct mod_hdcp_link *link, struct mod_hdcp_display *display, 329 struct mod_hdcp_output *output) 330 { 331 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 332 struct mod_hdcp_display *display_container = NULL; 333 334 HDCP_TOP_INTERFACE_TRACE_WITH_INDEX(hdcp, display->index); 335 memset(output, 0, sizeof(struct mod_hdcp_output)); 336 337 /* skip inactive display */ 338 if (display->state != MOD_HDCP_DISPLAY_ACTIVE) { 339 status = MOD_HDCP_STATUS_SUCCESS; 340 goto out; 341 } 342 343 /* check existing display container */ 344 if (get_active_display_at_index(hdcp, display->index)) { 345 status = MOD_HDCP_STATUS_SUCCESS; 346 goto out; 347 } 348 349 /* find an empty display container */ 350 display_container = get_empty_display_container(hdcp); 351 if (!display_container) { 352 status = MOD_HDCP_STATUS_DISPLAY_OUT_OF_BOUND; 353 goto out; 354 } 355 356 /* reset existing authentication status */ 357 status = reset_authentication(hdcp, output); 358 if (status != MOD_HDCP_STATUS_SUCCESS) 359 goto out; 360 361 /* reset retry counters */ 362 reset_retry_counts(hdcp); 363 364 /* reset error trace */ 365 memset(&hdcp->connection.trace, 0, sizeof(hdcp->connection.trace)); 366 367 /* add display to connection */ 368 hdcp->connection.link = *link; 369 *display_container = *display; 370 status = mod_hdcp_add_display_to_topology(hdcp, display_container); 371 372 if (status != MOD_HDCP_STATUS_SUCCESS) 373 goto out; 374 375 /* request authentication */ 376 if (current_state(hdcp) != HDCP_INITIALIZED) 377 set_state_id(hdcp, output, HDCP_INITIALIZED); 378 callback_in_ms(hdcp->connection.link.adjust.auth_delay * 1000, output); 379 out: 380 if (status != MOD_HDCP_STATUS_SUCCESS) 381 push_error_status(hdcp, status); 382 383 return status; 384 } 385 386 enum mod_hdcp_status mod_hdcp_remove_display(struct mod_hdcp *hdcp, 387 uint8_t index, struct mod_hdcp_output *output) 388 { 389 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 390 struct mod_hdcp_display *display = NULL; 391 392 HDCP_TOP_INTERFACE_TRACE_WITH_INDEX(hdcp, index); 393 memset(output, 0, sizeof(struct mod_hdcp_output)); 394 395 /* find display in connection */ 396 display = get_active_display_at_index(hdcp, index); 397 if (!display) { 398 status = MOD_HDCP_STATUS_SUCCESS; 399 goto out; 400 } 401 402 /* stop current authentication */ 403 status = reset_authentication(hdcp, output); 404 if (status != MOD_HDCP_STATUS_SUCCESS) 405 goto out; 406 407 /* clear retry counters */ 408 reset_retry_counts(hdcp); 409 410 /* reset error trace */ 411 memset(&hdcp->connection.trace, 0, sizeof(hdcp->connection.trace)); 412 413 /* remove display */ 414 status = mod_hdcp_remove_display_from_topology(hdcp, index); 415 if (status != MOD_HDCP_STATUS_SUCCESS) 416 goto out; 417 memset(display, 0, sizeof(struct mod_hdcp_display)); 418 419 /* request authentication when connection is not reset */ 420 if (current_state(hdcp) != HDCP_UNINITIALIZED) 421 callback_in_ms(hdcp->connection.link.adjust.auth_delay * 1000, 422 output); 423 out: 424 if (status != MOD_HDCP_STATUS_SUCCESS) 425 push_error_status(hdcp, status); 426 return status; 427 } 428 429 enum mod_hdcp_status mod_hdcp_update_display(struct mod_hdcp *hdcp, 430 uint8_t index, 431 struct mod_hdcp_link_adjustment *link_adjust, 432 struct mod_hdcp_display_adjustment *display_adjust, 433 struct mod_hdcp_output *output) 434 { 435 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 436 struct mod_hdcp_display *display = NULL; 437 438 HDCP_TOP_INTERFACE_TRACE_WITH_INDEX(hdcp, index); 439 memset(output, 0, sizeof(struct mod_hdcp_output)); 440 441 /* find display in connection */ 442 display = get_active_display_at_index(hdcp, index); 443 if (!display) { 444 status = MOD_HDCP_STATUS_DISPLAY_NOT_FOUND; 445 goto out; 446 } 447 448 /* skip if no changes */ 449 if (memcmp(link_adjust, &hdcp->connection.link.adjust, 450 sizeof(struct mod_hdcp_link_adjustment)) == 0 && 451 memcmp(display_adjust, &display->adjust, 452 sizeof(struct mod_hdcp_display_adjustment)) == 0) { 453 status = MOD_HDCP_STATUS_SUCCESS; 454 goto out; 455 } 456 457 if (memcmp(link_adjust, &hdcp->connection.link.adjust, 458 sizeof(struct mod_hdcp_link_adjustment)) == 0 && 459 memcmp(display_adjust, &display->adjust, 460 sizeof(struct mod_hdcp_display_adjustment)) != 0) { 461 status = update_display_adjustments(hdcp, display, display_adjust); 462 if (status != MOD_HDCP_STATUS_NOT_IMPLEMENTED) 463 goto out; 464 } 465 466 /* stop current authentication */ 467 status = reset_authentication(hdcp, output); 468 if (status != MOD_HDCP_STATUS_SUCCESS) 469 goto out; 470 471 /* clear retry counters */ 472 reset_retry_counts(hdcp); 473 474 /* reset error trace */ 475 memset(&hdcp->connection.trace, 0, sizeof(hdcp->connection.trace)); 476 477 /* set new adjustment */ 478 hdcp->connection.link.adjust = *link_adjust; 479 display->adjust = *display_adjust; 480 481 /* request authentication when connection is not reset */ 482 if (current_state(hdcp) != HDCP_UNINITIALIZED) 483 /* wait 100ms to debounce simultaneous updates for different indices */ 484 callback_in_ms(100, output); 485 486 out: 487 if (status != MOD_HDCP_STATUS_SUCCESS) 488 push_error_status(hdcp, status); 489 return status; 490 } 491 492 enum mod_hdcp_status mod_hdcp_query_display(struct mod_hdcp *hdcp, 493 uint8_t index, struct mod_hdcp_display_query *query) 494 { 495 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 496 struct mod_hdcp_display *display = NULL; 497 498 /* find display in connection */ 499 display = get_active_display_at_index(hdcp, index); 500 if (!display) { 501 status = MOD_HDCP_STATUS_DISPLAY_NOT_FOUND; 502 goto out; 503 } 504 505 /* populate query */ 506 query->link = &hdcp->connection.link; 507 query->display = display; 508 query->trace = &hdcp->connection.trace; 509 query->encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF; 510 511 if (is_display_encryption_enabled(display)) { 512 if (is_hdcp1(hdcp)) { 513 query->encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP1_ON; 514 } else if (is_hdcp2(hdcp)) { 515 if (query->link->adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_0) 516 query->encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE0_ON; 517 else if (query->link->adjust.hdcp2.force_type == MOD_HDCP_FORCE_TYPE_1) 518 query->encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON; 519 else 520 query->encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_ON; 521 } 522 } else { 523 query->encryption_status = MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF; 524 } 525 526 out: 527 return status; 528 } 529 530 enum mod_hdcp_status mod_hdcp_reset_connection(struct mod_hdcp *hdcp, 531 struct mod_hdcp_output *output) 532 { 533 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 534 535 HDCP_TOP_INTERFACE_TRACE(hdcp); 536 status = reset_connection(hdcp, output); 537 if (status != MOD_HDCP_STATUS_SUCCESS) 538 push_error_status(hdcp, status); 539 540 return status; 541 } 542 543 enum mod_hdcp_status mod_hdcp_process_event(struct mod_hdcp *hdcp, 544 enum mod_hdcp_event event, struct mod_hdcp_output *output) 545 { 546 enum mod_hdcp_status exec_status, trans_status, reset_status, status; 547 struct mod_hdcp_event_context event_ctx; 548 549 HDCP_EVENT_TRACE(hdcp, event); 550 memset(output, 0, sizeof(struct mod_hdcp_output)); 551 memset(&event_ctx, 0, sizeof(struct mod_hdcp_event_context)); 552 event_ctx.event = event; 553 554 exit_idle_optimizations(hdcp); 555 556 /* execute and transition */ 557 exec_status = execution(hdcp, &event_ctx, &hdcp->auth.trans_input); 558 trans_status = transition( 559 hdcp, &event_ctx, &hdcp->auth.trans_input, output); 560 if (trans_status == MOD_HDCP_STATUS_SUCCESS) { 561 status = MOD_HDCP_STATUS_SUCCESS; 562 } else if (exec_status == MOD_HDCP_STATUS_SUCCESS) { 563 status = MOD_HDCP_STATUS_INTERNAL_POLICY_FAILURE; 564 push_error_status(hdcp, status); 565 } else { 566 status = exec_status; 567 push_error_status(hdcp, status); 568 } 569 570 /* reset authentication if needed */ 571 if (trans_status == MOD_HDCP_STATUS_RESET_NEEDED) { 572 mod_hdcp_log_ddc_trace(hdcp); 573 reset_status = reset_authentication(hdcp, output); 574 if (reset_status != MOD_HDCP_STATUS_SUCCESS) 575 push_error_status(hdcp, reset_status); 576 } 577 578 /* Clear CP_IRQ status if needed */ 579 if (event_ctx.event == MOD_HDCP_EVENT_CPIRQ) { 580 status = mod_hdcp_clear_cp_irq_status(hdcp); 581 if (status != MOD_HDCP_STATUS_SUCCESS) 582 push_error_status(hdcp, status); 583 } 584 585 return status; 586 } 587 588 enum mod_hdcp_operation_mode mod_hdcp_signal_type_to_operation_mode( 589 enum signal_type signal) 590 { 591 enum mod_hdcp_operation_mode mode = MOD_HDCP_MODE_OFF; 592 593 switch (signal) { 594 case SIGNAL_TYPE_DVI_SINGLE_LINK: 595 case SIGNAL_TYPE_HDMI_TYPE_A: 596 mode = MOD_HDCP_MODE_DEFAULT; 597 break; 598 case SIGNAL_TYPE_EDP: 599 case SIGNAL_TYPE_DISPLAY_PORT: 600 case SIGNAL_TYPE_DISPLAY_PORT_MST: 601 mode = MOD_HDCP_MODE_DP; 602 break; 603 default: 604 break; 605 } 606 607 return mode; 608 } 609