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