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 inline enum mod_hdcp_status validate_bksv(struct mod_hdcp *hdcp) 29 { 30 uint64_t n = 0; 31 uint8_t count = 0; 32 33 memcpy(&n, hdcp->auth.msg.hdcp1.bksv, sizeof(uint64_t)); 34 35 while (n) { 36 count++; 37 n &= (n - 1); 38 } 39 return (count == 20) ? MOD_HDCP_STATUS_SUCCESS : 40 MOD_HDCP_STATUS_HDCP1_INVALID_BKSV; 41 } 42 43 static inline enum mod_hdcp_status check_ksv_ready(struct mod_hdcp *hdcp) 44 { 45 if (is_dp_hdcp(hdcp)) 46 return (hdcp->auth.msg.hdcp1.bstatus & DP_BSTATUS_READY) ? 47 MOD_HDCP_STATUS_SUCCESS : 48 MOD_HDCP_STATUS_HDCP1_KSV_LIST_NOT_READY; 49 return (hdcp->auth.msg.hdcp1.bcaps & DRM_HDCP_DDC_BCAPS_KSV_FIFO_READY) ? 50 MOD_HDCP_STATUS_SUCCESS : 51 MOD_HDCP_STATUS_HDCP1_KSV_LIST_NOT_READY; 52 } 53 54 static inline enum mod_hdcp_status check_hdcp_capable_dp(struct mod_hdcp *hdcp) 55 { 56 return (hdcp->auth.msg.hdcp1.bcaps & DP_BCAPS_HDCP_CAPABLE) ? 57 MOD_HDCP_STATUS_SUCCESS : 58 MOD_HDCP_STATUS_HDCP1_NOT_CAPABLE; 59 } 60 61 static inline enum mod_hdcp_status check_r0p_available_dp(struct mod_hdcp *hdcp) 62 { 63 enum mod_hdcp_status status; 64 if (is_dp_hdcp(hdcp)) { 65 status = (hdcp->auth.msg.hdcp1.bstatus & 66 DP_BSTATUS_R0_PRIME_READY) ? 67 MOD_HDCP_STATUS_SUCCESS : 68 MOD_HDCP_STATUS_HDCP1_R0_PRIME_PENDING; 69 } else { 70 status = MOD_HDCP_STATUS_INVALID_OPERATION; 71 } 72 return status; 73 } 74 75 static inline enum mod_hdcp_status check_link_integrity_dp( 76 struct mod_hdcp *hdcp) 77 { 78 return (hdcp->auth.msg.hdcp1.bstatus & 79 DP_BSTATUS_LINK_FAILURE) ? 80 MOD_HDCP_STATUS_HDCP1_LINK_INTEGRITY_FAILURE : 81 MOD_HDCP_STATUS_SUCCESS; 82 } 83 84 static inline enum mod_hdcp_status check_no_reauthentication_request_dp( 85 struct mod_hdcp *hdcp) 86 { 87 return (hdcp->auth.msg.hdcp1.bstatus & DP_BSTATUS_REAUTH_REQ) ? 88 MOD_HDCP_STATUS_HDCP1_REAUTH_REQUEST_ISSUED : 89 MOD_HDCP_STATUS_SUCCESS; 90 } 91 92 static inline enum mod_hdcp_status check_no_max_cascade(struct mod_hdcp *hdcp) 93 { 94 enum mod_hdcp_status status; 95 96 if (is_dp_hdcp(hdcp)) 97 status = DRM_HDCP_MAX_CASCADE_EXCEEDED(hdcp->auth.msg.hdcp1.binfo_dp >> 8) 98 ? MOD_HDCP_STATUS_HDCP1_MAX_CASCADE_EXCEEDED_FAILURE 99 : MOD_HDCP_STATUS_SUCCESS; 100 else 101 status = DRM_HDCP_MAX_CASCADE_EXCEEDED(hdcp->auth.msg.hdcp1.bstatus >> 8) 102 ? MOD_HDCP_STATUS_HDCP1_MAX_CASCADE_EXCEEDED_FAILURE 103 : MOD_HDCP_STATUS_SUCCESS; 104 return status; 105 } 106 107 static inline enum mod_hdcp_status check_no_max_devs(struct mod_hdcp *hdcp) 108 { 109 enum mod_hdcp_status status; 110 111 if (is_dp_hdcp(hdcp)) 112 status = DRM_HDCP_MAX_DEVICE_EXCEEDED(hdcp->auth.msg.hdcp1.binfo_dp) ? 113 MOD_HDCP_STATUS_HDCP1_MAX_DEVS_EXCEEDED_FAILURE : 114 MOD_HDCP_STATUS_SUCCESS; 115 else 116 status = DRM_HDCP_MAX_DEVICE_EXCEEDED(hdcp->auth.msg.hdcp1.bstatus) ? 117 MOD_HDCP_STATUS_HDCP1_MAX_DEVS_EXCEEDED_FAILURE : 118 MOD_HDCP_STATUS_SUCCESS; 119 return status; 120 } 121 122 static inline uint8_t get_device_count(struct mod_hdcp *hdcp) 123 { 124 return is_dp_hdcp(hdcp) ? 125 DRM_HDCP_NUM_DOWNSTREAM(hdcp->auth.msg.hdcp1.binfo_dp) : 126 DRM_HDCP_NUM_DOWNSTREAM(hdcp->auth.msg.hdcp1.bstatus); 127 } 128 129 static inline enum mod_hdcp_status check_device_count(struct mod_hdcp *hdcp) 130 { 131 /* Avoid device count == 0 to do authentication */ 132 if (0 == get_device_count(hdcp)) { 133 return MOD_HDCP_STATUS_HDCP1_DEVICE_COUNT_MISMATCH_FAILURE; 134 } 135 136 /* Some MST display may choose to report the internal panel as an HDCP RX. 137 * To update this condition with 1(because the immediate repeater's internal 138 * panel is possibly not included in DEVICE_COUNT) + get_device_count(hdcp). 139 * Device count must be greater than or equal to tracked hdcp displays. 140 */ 141 return ((1 + get_device_count(hdcp)) < get_active_display_count(hdcp)) ? 142 MOD_HDCP_STATUS_HDCP1_DEVICE_COUNT_MISMATCH_FAILURE : 143 MOD_HDCP_STATUS_SUCCESS; 144 } 145 146 static enum mod_hdcp_status wait_for_active_rx(struct mod_hdcp *hdcp, 147 struct mod_hdcp_event_context *event_ctx, 148 struct mod_hdcp_transition_input_hdcp1 *input) 149 { 150 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 151 152 if (event_ctx->event != MOD_HDCP_EVENT_CALLBACK) { 153 event_ctx->unexpected_event = 1; 154 goto out; 155 } 156 157 if (!mod_hdcp_execute_and_set(mod_hdcp_read_bksv, 158 &input->bksv_read, &status, 159 hdcp, "bksv_read")) 160 goto out; 161 if (!mod_hdcp_execute_and_set(mod_hdcp_read_bcaps, 162 &input->bcaps_read, &status, 163 hdcp, "bcaps_read")) 164 goto out; 165 out: 166 return status; 167 } 168 169 static enum mod_hdcp_status exchange_ksvs(struct mod_hdcp *hdcp, 170 struct mod_hdcp_event_context *event_ctx, 171 struct mod_hdcp_transition_input_hdcp1 *input) 172 { 173 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 174 175 if (event_ctx->event != MOD_HDCP_EVENT_CALLBACK) { 176 event_ctx->unexpected_event = 1; 177 goto out; 178 } 179 180 if (!mod_hdcp_execute_and_set(mod_hdcp_hdcp1_create_session, 181 &input->create_session, &status, 182 hdcp, "create_session")) 183 goto out; 184 if (!mod_hdcp_execute_and_set(mod_hdcp_write_an, 185 &input->an_write, &status, 186 hdcp, "an_write")) 187 goto out; 188 if (!mod_hdcp_execute_and_set(mod_hdcp_write_aksv, 189 &input->aksv_write, &status, 190 hdcp, "aksv_write")) 191 goto out; 192 if (!mod_hdcp_execute_and_set(mod_hdcp_read_bksv, 193 &input->bksv_read, &status, 194 hdcp, "bksv_read")) 195 goto out; 196 if (!mod_hdcp_execute_and_set(validate_bksv, 197 &input->bksv_validation, &status, 198 hdcp, "bksv_validation")) 199 goto out; 200 if (hdcp->auth.msg.hdcp1.ainfo) { 201 if (!mod_hdcp_execute_and_set(mod_hdcp_write_ainfo, 202 &input->ainfo_write, &status, 203 hdcp, "ainfo_write")) 204 goto out; 205 } 206 out: 207 return status; 208 } 209 210 static enum mod_hdcp_status computations_validate_rx_test_for_repeater( 211 struct mod_hdcp *hdcp, 212 struct mod_hdcp_event_context *event_ctx, 213 struct mod_hdcp_transition_input_hdcp1 *input) 214 { 215 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 216 217 if (event_ctx->event != MOD_HDCP_EVENT_CALLBACK) { 218 event_ctx->unexpected_event = 1; 219 goto out; 220 } 221 222 if (!mod_hdcp_execute_and_set(mod_hdcp_read_r0p, 223 &input->r0p_read, &status, 224 hdcp, "r0p_read")) 225 goto out; 226 if (!mod_hdcp_execute_and_set(mod_hdcp_hdcp1_validate_rx, 227 &input->rx_validation, &status, 228 hdcp, "rx_validation")) 229 goto out; 230 if (hdcp->connection.is_repeater) { 231 if (!hdcp->connection.link.adjust.hdcp1.postpone_encryption) 232 if (!mod_hdcp_execute_and_set( 233 mod_hdcp_hdcp1_enable_encryption, 234 &input->encryption, &status, 235 hdcp, "encryption")) 236 goto out; 237 } else { 238 if (!mod_hdcp_execute_and_set(mod_hdcp_hdcp1_enable_encryption, 239 &input->encryption, &status, 240 hdcp, "encryption")) 241 goto out; 242 if (is_dp_mst_hdcp(hdcp)) 243 if (!mod_hdcp_execute_and_set( 244 mod_hdcp_hdcp1_enable_dp_stream_encryption, 245 &input->stream_encryption_dp, &status, 246 hdcp, "stream_encryption_dp")) 247 goto out; 248 } 249 out: 250 return status; 251 } 252 253 static enum mod_hdcp_status authenticated(struct mod_hdcp *hdcp, 254 struct mod_hdcp_event_context *event_ctx, 255 struct mod_hdcp_transition_input_hdcp1 *input) 256 { 257 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 258 259 if (event_ctx->event != MOD_HDCP_EVENT_CALLBACK) { 260 event_ctx->unexpected_event = 1; 261 goto out; 262 } 263 264 mod_hdcp_execute_and_set(mod_hdcp_hdcp1_link_maintenance, 265 &input->link_maintenance, &status, 266 hdcp, "link_maintenance"); 267 268 if (status != MOD_HDCP_STATUS_SUCCESS) 269 mod_hdcp_save_current_encryption_states(hdcp); 270 out: 271 return status; 272 } 273 274 static enum mod_hdcp_status wait_for_ready(struct mod_hdcp *hdcp, 275 struct mod_hdcp_event_context *event_ctx, 276 struct mod_hdcp_transition_input_hdcp1 *input) 277 { 278 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 279 280 if (event_ctx->event != MOD_HDCP_EVENT_CALLBACK && 281 event_ctx->event != MOD_HDCP_EVENT_CPIRQ && 282 event_ctx->event != MOD_HDCP_EVENT_WATCHDOG_TIMEOUT) { 283 event_ctx->unexpected_event = 1; 284 goto out; 285 } 286 287 if (is_dp_hdcp(hdcp)) { 288 if (!mod_hdcp_execute_and_set(mod_hdcp_read_bstatus, 289 &input->bstatus_read, &status, 290 hdcp, "bstatus_read")) 291 goto out; 292 if (!mod_hdcp_execute_and_set(check_link_integrity_dp, 293 &input->link_integrity_check, &status, 294 hdcp, "link_integrity_check")) 295 goto out; 296 if (!mod_hdcp_execute_and_set(check_no_reauthentication_request_dp, 297 &input->reauth_request_check, &status, 298 hdcp, "reauth_request_check")) 299 goto out; 300 } else { 301 if (!mod_hdcp_execute_and_set(mod_hdcp_read_bcaps, 302 &input->bcaps_read, &status, 303 hdcp, "bcaps_read")) 304 goto out; 305 } 306 if (!mod_hdcp_execute_and_set(check_ksv_ready, 307 &input->ready_check, &status, 308 hdcp, "ready_check")) 309 goto out; 310 out: 311 return status; 312 } 313 314 static enum mod_hdcp_status read_ksv_list(struct mod_hdcp *hdcp, 315 struct mod_hdcp_event_context *event_ctx, 316 struct mod_hdcp_transition_input_hdcp1 *input) 317 { 318 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 319 uint8_t device_count; 320 321 if (event_ctx->event != MOD_HDCP_EVENT_CALLBACK) { 322 event_ctx->unexpected_event = 1; 323 goto out; 324 } 325 326 if (is_dp_hdcp(hdcp)) { 327 if (!mod_hdcp_execute_and_set(mod_hdcp_read_binfo, 328 &input->binfo_read_dp, &status, 329 hdcp, "binfo_read_dp")) 330 goto out; 331 } else { 332 if (!mod_hdcp_execute_and_set(mod_hdcp_read_bstatus, 333 &input->bstatus_read, &status, 334 hdcp, "bstatus_read")) 335 goto out; 336 } 337 if (!mod_hdcp_execute_and_set(check_no_max_cascade, 338 &input->max_cascade_check, &status, 339 hdcp, "max_cascade_check")) 340 goto out; 341 if (!mod_hdcp_execute_and_set(check_no_max_devs, 342 &input->max_devs_check, &status, 343 hdcp, "max_devs_check")) 344 goto out; 345 if (!mod_hdcp_execute_and_set(check_device_count, 346 &input->device_count_check, &status, 347 hdcp, "device_count_check")) 348 goto out; 349 device_count = get_device_count(hdcp); 350 hdcp->auth.msg.hdcp1.ksvlist_size = device_count*5; 351 if (!mod_hdcp_execute_and_set(mod_hdcp_read_ksvlist, 352 &input->ksvlist_read, &status, 353 hdcp, "ksvlist_read")) 354 goto out; 355 if (!mod_hdcp_execute_and_set(mod_hdcp_read_vp, 356 &input->vp_read, &status, 357 hdcp, "vp_read")) 358 goto out; 359 if (!mod_hdcp_execute_and_set(mod_hdcp_hdcp1_validate_ksvlist_vp, 360 &input->ksvlist_vp_validation, &status, 361 hdcp, "ksvlist_vp_validation")) 362 goto out; 363 if (input->encryption != PASS) 364 if (!mod_hdcp_execute_and_set(mod_hdcp_hdcp1_enable_encryption, 365 &input->encryption, &status, 366 hdcp, "encryption")) 367 goto out; 368 if (is_dp_mst_hdcp(hdcp)) 369 if (!mod_hdcp_execute_and_set( 370 mod_hdcp_hdcp1_enable_dp_stream_encryption, 371 &input->stream_encryption_dp, &status, 372 hdcp, "stream_encryption_dp")) 373 goto out; 374 out: 375 return status; 376 } 377 378 static enum mod_hdcp_status determine_rx_hdcp_capable_dp(struct mod_hdcp *hdcp, 379 struct mod_hdcp_event_context *event_ctx, 380 struct mod_hdcp_transition_input_hdcp1 *input) 381 { 382 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 383 384 if (event_ctx->event != MOD_HDCP_EVENT_CALLBACK) { 385 event_ctx->unexpected_event = 1; 386 goto out; 387 } 388 389 if (!mod_hdcp_execute_and_set(mod_hdcp_read_bcaps, 390 &input->bcaps_read, &status, 391 hdcp, "bcaps_read")) 392 goto out; 393 if (!mod_hdcp_execute_and_set(check_hdcp_capable_dp, 394 &input->hdcp_capable_dp, &status, 395 hdcp, "hdcp_capable_dp")) 396 goto out; 397 out: 398 return status; 399 } 400 401 static enum mod_hdcp_status wait_for_r0_prime_dp(struct mod_hdcp *hdcp, 402 struct mod_hdcp_event_context *event_ctx, 403 struct mod_hdcp_transition_input_hdcp1 *input) 404 { 405 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 406 407 if (event_ctx->event != MOD_HDCP_EVENT_CPIRQ && 408 event_ctx->event != MOD_HDCP_EVENT_WATCHDOG_TIMEOUT) { 409 event_ctx->unexpected_event = 1; 410 goto out; 411 } 412 413 if (!mod_hdcp_execute_and_set(mod_hdcp_read_bstatus, 414 &input->bstatus_read, &status, 415 hdcp, "bstatus_read")) 416 goto out; 417 if (!mod_hdcp_execute_and_set(check_r0p_available_dp, 418 &input->r0p_available_dp, &status, 419 hdcp, "r0p_available_dp")) 420 goto out; 421 out: 422 return status; 423 } 424 425 static enum mod_hdcp_status authenticated_dp(struct mod_hdcp *hdcp, 426 struct mod_hdcp_event_context *event_ctx, 427 struct mod_hdcp_transition_input_hdcp1 *input) 428 { 429 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 430 431 if (event_ctx->event != MOD_HDCP_EVENT_CPIRQ) { 432 event_ctx->unexpected_event = 1; 433 goto out; 434 } 435 436 if (status == MOD_HDCP_STATUS_SUCCESS) 437 mod_hdcp_execute_and_set(mod_hdcp_read_bstatus, 438 &input->bstatus_read, &status, 439 hdcp, "bstatus_read"); 440 if (status == MOD_HDCP_STATUS_SUCCESS) 441 mod_hdcp_execute_and_set(check_link_integrity_dp, 442 &input->link_integrity_check, &status, 443 hdcp, "link_integrity_check"); 444 if (status == MOD_HDCP_STATUS_SUCCESS) 445 mod_hdcp_execute_and_set(check_no_reauthentication_request_dp, 446 &input->reauth_request_check, &status, 447 hdcp, "reauth_request_check"); 448 449 if (status != MOD_HDCP_STATUS_SUCCESS) 450 mod_hdcp_save_current_encryption_states(hdcp); 451 out: 452 return status; 453 } 454 455 uint8_t mod_hdcp_execute_and_set( 456 mod_hdcp_action func, uint8_t *flag, 457 enum mod_hdcp_status *status, struct mod_hdcp *hdcp, char *str) 458 { 459 *status = func(hdcp); 460 if (*status == MOD_HDCP_STATUS_SUCCESS && *flag != PASS) { 461 HDCP_INPUT_PASS_TRACE(hdcp, str); 462 *flag = PASS; 463 } else if (*status != MOD_HDCP_STATUS_SUCCESS && *flag != FAIL) { 464 HDCP_INPUT_FAIL_TRACE(hdcp, str); 465 *flag = FAIL; 466 } 467 return (*status == MOD_HDCP_STATUS_SUCCESS); 468 } 469 470 enum mod_hdcp_status mod_hdcp_hdcp1_execution(struct mod_hdcp *hdcp, 471 struct mod_hdcp_event_context *event_ctx, 472 struct mod_hdcp_transition_input_hdcp1 *input) 473 { 474 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 475 476 switch (current_state(hdcp)) { 477 case H1_A0_WAIT_FOR_ACTIVE_RX: 478 status = wait_for_active_rx(hdcp, event_ctx, input); 479 break; 480 case H1_A1_EXCHANGE_KSVS: 481 status = exchange_ksvs(hdcp, event_ctx, input); 482 break; 483 case H1_A2_COMPUTATIONS_A3_VALIDATE_RX_A6_TEST_FOR_REPEATER: 484 status = computations_validate_rx_test_for_repeater(hdcp, 485 event_ctx, input); 486 break; 487 case H1_A45_AUTHENTICATED: 488 status = authenticated(hdcp, event_ctx, input); 489 break; 490 case H1_A8_WAIT_FOR_READY: 491 status = wait_for_ready(hdcp, event_ctx, input); 492 break; 493 case H1_A9_READ_KSV_LIST: 494 status = read_ksv_list(hdcp, event_ctx, input); 495 break; 496 default: 497 status = MOD_HDCP_STATUS_INVALID_STATE; 498 break; 499 } 500 501 return status; 502 } 503 504 extern enum mod_hdcp_status mod_hdcp_hdcp1_dp_execution(struct mod_hdcp *hdcp, 505 struct mod_hdcp_event_context *event_ctx, 506 struct mod_hdcp_transition_input_hdcp1 *input) 507 { 508 enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; 509 510 switch (current_state(hdcp)) { 511 case D1_A0_DETERMINE_RX_HDCP_CAPABLE: 512 status = determine_rx_hdcp_capable_dp(hdcp, event_ctx, input); 513 break; 514 case D1_A1_EXCHANGE_KSVS: 515 status = exchange_ksvs(hdcp, event_ctx, input); 516 break; 517 case D1_A23_WAIT_FOR_R0_PRIME: 518 status = wait_for_r0_prime_dp(hdcp, event_ctx, input); 519 break; 520 case D1_A2_COMPUTATIONS_A3_VALIDATE_RX_A5_TEST_FOR_REPEATER: 521 status = computations_validate_rx_test_for_repeater( 522 hdcp, event_ctx, input); 523 break; 524 case D1_A4_AUTHENTICATED: 525 status = authenticated_dp(hdcp, event_ctx, input); 526 break; 527 case D1_A6_WAIT_FOR_READY: 528 status = wait_for_ready(hdcp, event_ctx, input); 529 break; 530 case D1_A7_READ_KSV_LIST: 531 status = read_ksv_list(hdcp, event_ctx, input); 532 break; 533 default: 534 status = MOD_HDCP_STATUS_INVALID_STATE; 535 break; 536 } 537 538 return status; 539 } 540