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