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