1 /* SPDX-License-Identifier: MIT */ 2 /* 3 * Copyright (C) 2020 Google, Inc. 4 * 5 * Authors: 6 * Sean Paul <seanpaul@chromium.org> 7 */ 8 9 #include <drm/display/drm_dp_helper.h> 10 #include <drm/display/drm_dp_mst_helper.h> 11 #include <drm/display/drm_hdcp_helper.h> 12 #include <drm/drm_print.h> 13 14 #include "i915_reg.h" 15 #include "intel_ddi.h" 16 #include "intel_de.h" 17 #include "intel_display_types.h" 18 #include "intel_dp.h" 19 #include "intel_dp_hdcp.h" 20 #include "intel_hdcp.h" 21 #include "intel_hdcp_regs.h" 22 23 static u32 transcoder_to_stream_enc_status(enum transcoder cpu_transcoder) 24 { 25 switch (cpu_transcoder) { 26 case TRANSCODER_A: 27 return HDCP_STATUS_STREAM_A_ENC; 28 case TRANSCODER_B: 29 return HDCP_STATUS_STREAM_B_ENC; 30 case TRANSCODER_C: 31 return HDCP_STATUS_STREAM_C_ENC; 32 case TRANSCODER_D: 33 return HDCP_STATUS_STREAM_D_ENC; 34 default: 35 return 0; 36 } 37 } 38 39 static void intel_dp_hdcp_wait_for_cp_irq(struct intel_hdcp *hdcp, int timeout) 40 { 41 long ret; 42 43 #define C (hdcp->cp_irq_count_cached != atomic_read(&hdcp->cp_irq_count)) 44 ret = wait_event_interruptible_timeout(hdcp->cp_irq_queue, C, 45 msecs_to_jiffies(timeout)); 46 47 if (!ret) 48 DRM_DEBUG_KMS("Timedout at waiting for CP_IRQ\n"); 49 } 50 51 static 52 int intel_dp_hdcp_write_an_aksv(struct intel_digital_port *dig_port, 53 u8 *an) 54 { 55 struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev); 56 u8 aksv[DRM_HDCP_KSV_LEN] = {}; 57 ssize_t dpcd_ret; 58 59 /* Output An first, that's easy */ 60 dpcd_ret = drm_dp_dpcd_write(&dig_port->dp.aux, DP_AUX_HDCP_AN, 61 an, DRM_HDCP_AN_LEN); 62 if (dpcd_ret != DRM_HDCP_AN_LEN) { 63 drm_dbg_kms(&i915->drm, 64 "Failed to write An over DP/AUX (%zd)\n", 65 dpcd_ret); 66 return dpcd_ret >= 0 ? -EIO : dpcd_ret; 67 } 68 69 /* 70 * Since Aksv is Oh-So-Secret, we can't access it in software. So we 71 * send an empty buffer of the correct length through the DP helpers. On 72 * the other side, in the transfer hook, we'll generate a flag based on 73 * the destination address which will tickle the hardware to output the 74 * Aksv on our behalf after the header is sent. 75 */ 76 dpcd_ret = drm_dp_dpcd_write(&dig_port->dp.aux, DP_AUX_HDCP_AKSV, 77 aksv, DRM_HDCP_KSV_LEN); 78 if (dpcd_ret != DRM_HDCP_KSV_LEN) { 79 drm_dbg_kms(&i915->drm, 80 "Failed to write Aksv over DP/AUX (%zd)\n", 81 dpcd_ret); 82 return dpcd_ret >= 0 ? -EIO : dpcd_ret; 83 } 84 return 0; 85 } 86 87 static int intel_dp_hdcp_read_bksv(struct intel_digital_port *dig_port, 88 u8 *bksv) 89 { 90 struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev); 91 ssize_t ret; 92 93 ret = drm_dp_dpcd_read(&dig_port->dp.aux, DP_AUX_HDCP_BKSV, bksv, 94 DRM_HDCP_KSV_LEN); 95 if (ret != DRM_HDCP_KSV_LEN) { 96 drm_dbg_kms(&i915->drm, 97 "Read Bksv from DP/AUX failed (%zd)\n", ret); 98 return ret >= 0 ? -EIO : ret; 99 } 100 return 0; 101 } 102 103 static int intel_dp_hdcp_read_bstatus(struct intel_digital_port *dig_port, 104 u8 *bstatus) 105 { 106 struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev); 107 ssize_t ret; 108 109 /* 110 * For some reason the HDMI and DP HDCP specs call this register 111 * definition by different names. In the HDMI spec, it's called BSTATUS, 112 * but in DP it's called BINFO. 113 */ 114 ret = drm_dp_dpcd_read(&dig_port->dp.aux, DP_AUX_HDCP_BINFO, 115 bstatus, DRM_HDCP_BSTATUS_LEN); 116 if (ret != DRM_HDCP_BSTATUS_LEN) { 117 drm_dbg_kms(&i915->drm, 118 "Read bstatus from DP/AUX failed (%zd)\n", ret); 119 return ret >= 0 ? -EIO : ret; 120 } 121 return 0; 122 } 123 124 static 125 int intel_dp_hdcp_read_bcaps(struct intel_digital_port *dig_port, 126 u8 *bcaps) 127 { 128 struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev); 129 ssize_t ret; 130 131 ret = drm_dp_dpcd_read(&dig_port->dp.aux, DP_AUX_HDCP_BCAPS, 132 bcaps, 1); 133 if (ret != 1) { 134 drm_dbg_kms(&i915->drm, 135 "Read bcaps from DP/AUX failed (%zd)\n", ret); 136 return ret >= 0 ? -EIO : ret; 137 } 138 139 return 0; 140 } 141 142 static 143 int intel_dp_hdcp_repeater_present(struct intel_digital_port *dig_port, 144 bool *repeater_present) 145 { 146 ssize_t ret; 147 u8 bcaps; 148 149 ret = intel_dp_hdcp_read_bcaps(dig_port, &bcaps); 150 if (ret) 151 return ret; 152 153 *repeater_present = bcaps & DP_BCAPS_REPEATER_PRESENT; 154 return 0; 155 } 156 157 static 158 int intel_dp_hdcp_read_ri_prime(struct intel_digital_port *dig_port, 159 u8 *ri_prime) 160 { 161 struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev); 162 ssize_t ret; 163 164 ret = drm_dp_dpcd_read(&dig_port->dp.aux, DP_AUX_HDCP_RI_PRIME, 165 ri_prime, DRM_HDCP_RI_LEN); 166 if (ret != DRM_HDCP_RI_LEN) { 167 drm_dbg_kms(&i915->drm, "Read Ri' from DP/AUX failed (%zd)\n", 168 ret); 169 return ret >= 0 ? -EIO : ret; 170 } 171 return 0; 172 } 173 174 static 175 int intel_dp_hdcp_read_ksv_ready(struct intel_digital_port *dig_port, 176 bool *ksv_ready) 177 { 178 struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev); 179 ssize_t ret; 180 u8 bstatus; 181 182 ret = drm_dp_dpcd_read(&dig_port->dp.aux, DP_AUX_HDCP_BSTATUS, 183 &bstatus, 1); 184 if (ret != 1) { 185 drm_dbg_kms(&i915->drm, 186 "Read bstatus from DP/AUX failed (%zd)\n", ret); 187 return ret >= 0 ? -EIO : ret; 188 } 189 *ksv_ready = bstatus & DP_BSTATUS_READY; 190 return 0; 191 } 192 193 static 194 int intel_dp_hdcp_read_ksv_fifo(struct intel_digital_port *dig_port, 195 int num_downstream, u8 *ksv_fifo) 196 { 197 struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev); 198 ssize_t ret; 199 int i; 200 201 /* KSV list is read via 15 byte window (3 entries @ 5 bytes each) */ 202 for (i = 0; i < num_downstream; i += 3) { 203 size_t len = min(num_downstream - i, 3) * DRM_HDCP_KSV_LEN; 204 ret = drm_dp_dpcd_read(&dig_port->dp.aux, 205 DP_AUX_HDCP_KSV_FIFO, 206 ksv_fifo + i * DRM_HDCP_KSV_LEN, 207 len); 208 if (ret != len) { 209 drm_dbg_kms(&i915->drm, 210 "Read ksv[%d] from DP/AUX failed (%zd)\n", 211 i, ret); 212 return ret >= 0 ? -EIO : ret; 213 } 214 } 215 return 0; 216 } 217 218 static 219 int intel_dp_hdcp_read_v_prime_part(struct intel_digital_port *dig_port, 220 int i, u32 *part) 221 { 222 struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev); 223 ssize_t ret; 224 225 if (i >= DRM_HDCP_V_PRIME_NUM_PARTS) 226 return -EINVAL; 227 228 ret = drm_dp_dpcd_read(&dig_port->dp.aux, 229 DP_AUX_HDCP_V_PRIME(i), part, 230 DRM_HDCP_V_PRIME_PART_LEN); 231 if (ret != DRM_HDCP_V_PRIME_PART_LEN) { 232 drm_dbg_kms(&i915->drm, 233 "Read v'[%d] from DP/AUX failed (%zd)\n", i, ret); 234 return ret >= 0 ? -EIO : ret; 235 } 236 return 0; 237 } 238 239 static 240 int intel_dp_hdcp_toggle_signalling(struct intel_digital_port *dig_port, 241 enum transcoder cpu_transcoder, 242 bool enable) 243 { 244 /* Not used for single stream DisplayPort setups */ 245 return 0; 246 } 247 248 static 249 bool intel_dp_hdcp_check_link(struct intel_digital_port *dig_port, 250 struct intel_connector *connector) 251 { 252 struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev); 253 ssize_t ret; 254 u8 bstatus; 255 256 ret = drm_dp_dpcd_read(&dig_port->dp.aux, DP_AUX_HDCP_BSTATUS, 257 &bstatus, 1); 258 if (ret != 1) { 259 drm_dbg_kms(&i915->drm, 260 "Read bstatus from DP/AUX failed (%zd)\n", ret); 261 return false; 262 } 263 264 return !(bstatus & (DP_BSTATUS_LINK_FAILURE | DP_BSTATUS_REAUTH_REQ)); 265 } 266 267 static 268 int intel_dp_hdcp_capable(struct intel_digital_port *dig_port, 269 bool *hdcp_capable) 270 { 271 ssize_t ret; 272 u8 bcaps; 273 274 ret = intel_dp_hdcp_read_bcaps(dig_port, &bcaps); 275 if (ret) 276 return ret; 277 278 *hdcp_capable = bcaps & DP_BCAPS_HDCP_CAPABLE; 279 return 0; 280 } 281 282 struct hdcp2_dp_errata_stream_type { 283 u8 msg_id; 284 u8 stream_type; 285 } __packed; 286 287 struct hdcp2_dp_msg_data { 288 u8 msg_id; 289 u32 offset; 290 bool msg_detectable; 291 u32 timeout; 292 u32 timeout2; /* Added for non_paired situation */ 293 /* Timeout to read entire msg */ 294 u32 msg_read_timeout; 295 }; 296 297 static const struct hdcp2_dp_msg_data hdcp2_dp_msg_data[] = { 298 { HDCP_2_2_AKE_INIT, DP_HDCP_2_2_AKE_INIT_OFFSET, false, 0, 0, 0}, 299 { HDCP_2_2_AKE_SEND_CERT, DP_HDCP_2_2_AKE_SEND_CERT_OFFSET, 300 false, HDCP_2_2_CERT_TIMEOUT_MS, 0, HDCP_2_2_DP_CERT_READ_TIMEOUT_MS}, 301 { HDCP_2_2_AKE_NO_STORED_KM, DP_HDCP_2_2_AKE_NO_STORED_KM_OFFSET, 302 false, 0, 0, 0 }, 303 { HDCP_2_2_AKE_STORED_KM, DP_HDCP_2_2_AKE_STORED_KM_OFFSET, 304 false, 0, 0, 0 }, 305 { HDCP_2_2_AKE_SEND_HPRIME, DP_HDCP_2_2_AKE_SEND_HPRIME_OFFSET, 306 true, HDCP_2_2_HPRIME_PAIRED_TIMEOUT_MS, 307 HDCP_2_2_HPRIME_NO_PAIRED_TIMEOUT_MS, HDCP_2_2_DP_HPRIME_READ_TIMEOUT_MS}, 308 { HDCP_2_2_AKE_SEND_PAIRING_INFO, 309 DP_HDCP_2_2_AKE_SEND_PAIRING_INFO_OFFSET, true, 310 HDCP_2_2_PAIRING_TIMEOUT_MS, 0, HDCP_2_2_DP_PAIRING_READ_TIMEOUT_MS }, 311 { HDCP_2_2_LC_INIT, DP_HDCP_2_2_LC_INIT_OFFSET, false, 0, 0, 0 }, 312 { HDCP_2_2_LC_SEND_LPRIME, DP_HDCP_2_2_LC_SEND_LPRIME_OFFSET, 313 false, HDCP_2_2_DP_LPRIME_TIMEOUT_MS, 0, 0 }, 314 { HDCP_2_2_SKE_SEND_EKS, DP_HDCP_2_2_SKE_SEND_EKS_OFFSET, false, 315 0, 0, 0 }, 316 { HDCP_2_2_REP_SEND_RECVID_LIST, 317 DP_HDCP_2_2_REP_SEND_RECVID_LIST_OFFSET, true, 318 HDCP_2_2_RECVID_LIST_TIMEOUT_MS, 0, 0 }, 319 { HDCP_2_2_REP_SEND_ACK, DP_HDCP_2_2_REP_SEND_ACK_OFFSET, false, 320 0, 0, 0 }, 321 { HDCP_2_2_REP_STREAM_MANAGE, 322 DP_HDCP_2_2_REP_STREAM_MANAGE_OFFSET, false, 323 0, 0, 0}, 324 { HDCP_2_2_REP_STREAM_READY, DP_HDCP_2_2_REP_STREAM_READY_OFFSET, 325 false, HDCP_2_2_STREAM_READY_TIMEOUT_MS, 0, 0 }, 326 /* local define to shovel this through the write_2_2 interface */ 327 #define HDCP_2_2_ERRATA_DP_STREAM_TYPE 50 328 { HDCP_2_2_ERRATA_DP_STREAM_TYPE, 329 DP_HDCP_2_2_REG_STREAM_TYPE_OFFSET, false, 330 0, 0 }, 331 }; 332 333 static int 334 intel_dp_hdcp2_read_rx_status(struct intel_connector *connector, 335 u8 *rx_status) 336 { 337 struct drm_i915_private *i915 = to_i915(connector->base.dev); 338 struct intel_digital_port *dig_port = intel_attached_dig_port(connector); 339 struct drm_dp_aux *aux = &dig_port->dp.aux; 340 ssize_t ret; 341 342 ret = drm_dp_dpcd_read(aux, 343 DP_HDCP_2_2_REG_RXSTATUS_OFFSET, rx_status, 344 HDCP_2_2_DP_RXSTATUS_LEN); 345 if (ret != HDCP_2_2_DP_RXSTATUS_LEN) { 346 drm_dbg_kms(&i915->drm, 347 "Read bstatus from DP/AUX failed (%zd)\n", ret); 348 return ret >= 0 ? -EIO : ret; 349 } 350 351 return 0; 352 } 353 354 static 355 int hdcp2_detect_msg_availability(struct intel_connector *connector, 356 u8 msg_id, bool *msg_ready) 357 { 358 u8 rx_status; 359 int ret; 360 361 *msg_ready = false; 362 ret = intel_dp_hdcp2_read_rx_status(connector, &rx_status); 363 if (ret < 0) 364 return ret; 365 366 switch (msg_id) { 367 case HDCP_2_2_AKE_SEND_HPRIME: 368 if (HDCP_2_2_DP_RXSTATUS_H_PRIME(rx_status)) 369 *msg_ready = true; 370 break; 371 case HDCP_2_2_AKE_SEND_PAIRING_INFO: 372 if (HDCP_2_2_DP_RXSTATUS_PAIRING(rx_status)) 373 *msg_ready = true; 374 break; 375 case HDCP_2_2_REP_SEND_RECVID_LIST: 376 if (HDCP_2_2_DP_RXSTATUS_READY(rx_status)) 377 *msg_ready = true; 378 break; 379 default: 380 DRM_ERROR("Unidentified msg_id: %d\n", msg_id); 381 return -EINVAL; 382 } 383 384 return 0; 385 } 386 387 static ssize_t 388 intel_dp_hdcp2_wait_for_msg(struct intel_connector *connector, 389 const struct hdcp2_dp_msg_data *hdcp2_msg_data) 390 { 391 struct drm_i915_private *i915 = to_i915(connector->base.dev); 392 struct intel_digital_port *dig_port = intel_attached_dig_port(connector); 393 struct intel_dp *dp = &dig_port->dp; 394 struct intel_hdcp *hdcp = &dp->attached_connector->hdcp; 395 u8 msg_id = hdcp2_msg_data->msg_id; 396 int ret, timeout; 397 bool msg_ready = false; 398 399 if (msg_id == HDCP_2_2_AKE_SEND_HPRIME && !hdcp->is_paired) 400 timeout = hdcp2_msg_data->timeout2; 401 else 402 timeout = hdcp2_msg_data->timeout; 403 404 /* 405 * There is no way to detect the CERT, LPRIME and STREAM_READY 406 * availability. So Wait for timeout and read the msg. 407 */ 408 if (!hdcp2_msg_data->msg_detectable) { 409 mdelay(timeout); 410 ret = 0; 411 } else { 412 /* 413 * As we want to check the msg availability at timeout, Ignoring 414 * the timeout at wait for CP_IRQ. 415 */ 416 intel_dp_hdcp_wait_for_cp_irq(hdcp, timeout); 417 ret = hdcp2_detect_msg_availability(connector, msg_id, 418 &msg_ready); 419 if (!msg_ready) 420 ret = -ETIMEDOUT; 421 } 422 423 if (ret) 424 drm_dbg_kms(&i915->drm, 425 "msg_id %d, ret %d, timeout(mSec): %d\n", 426 hdcp2_msg_data->msg_id, ret, timeout); 427 428 return ret; 429 } 430 431 static const struct hdcp2_dp_msg_data *get_hdcp2_dp_msg_data(u8 msg_id) 432 { 433 int i; 434 435 for (i = 0; i < ARRAY_SIZE(hdcp2_dp_msg_data); i++) 436 if (hdcp2_dp_msg_data[i].msg_id == msg_id) 437 return &hdcp2_dp_msg_data[i]; 438 439 return NULL; 440 } 441 442 static 443 int intel_dp_hdcp2_write_msg(struct intel_connector *connector, 444 void *buf, size_t size) 445 { 446 unsigned int offset; 447 u8 *byte = buf; 448 ssize_t ret, bytes_to_write, len; 449 struct intel_digital_port *dig_port = intel_attached_dig_port(connector); 450 struct drm_dp_aux *aux = &dig_port->dp.aux; 451 const struct hdcp2_dp_msg_data *hdcp2_msg_data; 452 453 hdcp2_msg_data = get_hdcp2_dp_msg_data(*byte); 454 if (!hdcp2_msg_data) 455 return -EINVAL; 456 457 offset = hdcp2_msg_data->offset; 458 459 /* No msg_id in DP HDCP2.2 msgs */ 460 bytes_to_write = size - 1; 461 byte++; 462 463 while (bytes_to_write) { 464 len = bytes_to_write > DP_AUX_MAX_PAYLOAD_BYTES ? 465 DP_AUX_MAX_PAYLOAD_BYTES : bytes_to_write; 466 467 ret = drm_dp_dpcd_write(aux, 468 offset, (void *)byte, len); 469 if (ret < 0) 470 return ret; 471 472 bytes_to_write -= ret; 473 byte += ret; 474 offset += ret; 475 } 476 477 return size; 478 } 479 480 static 481 ssize_t get_receiver_id_list_rx_info(struct intel_connector *connector, 482 u32 *dev_cnt, u8 *byte) 483 { 484 struct intel_digital_port *dig_port = intel_attached_dig_port(connector); 485 struct drm_dp_aux *aux = &dig_port->dp.aux; 486 ssize_t ret; 487 u8 *rx_info = byte; 488 489 ret = drm_dp_dpcd_read(aux, 490 DP_HDCP_2_2_REG_RXINFO_OFFSET, 491 (void *)rx_info, HDCP_2_2_RXINFO_LEN); 492 if (ret != HDCP_2_2_RXINFO_LEN) 493 return ret >= 0 ? -EIO : ret; 494 495 *dev_cnt = (HDCP_2_2_DEV_COUNT_HI(rx_info[0]) << 4 | 496 HDCP_2_2_DEV_COUNT_LO(rx_info[1])); 497 498 if (*dev_cnt > HDCP_2_2_MAX_DEVICE_COUNT) 499 *dev_cnt = HDCP_2_2_MAX_DEVICE_COUNT; 500 501 return ret; 502 } 503 504 static 505 int intel_dp_hdcp2_read_msg(struct intel_connector *connector, 506 u8 msg_id, void *buf, size_t size) 507 { 508 struct intel_digital_port *dig_port = intel_attached_dig_port(connector); 509 struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev); 510 struct drm_dp_aux *aux = &dig_port->dp.aux; 511 struct intel_dp *dp = &dig_port->dp; 512 struct intel_hdcp *hdcp = &dp->attached_connector->hdcp; 513 unsigned int offset; 514 u8 *byte = buf; 515 ssize_t ret, bytes_to_recv, len; 516 const struct hdcp2_dp_msg_data *hdcp2_msg_data; 517 ktime_t msg_end = ktime_set(0, 0); 518 bool msg_expired; 519 u32 dev_cnt; 520 521 hdcp2_msg_data = get_hdcp2_dp_msg_data(msg_id); 522 if (!hdcp2_msg_data) 523 return -EINVAL; 524 offset = hdcp2_msg_data->offset; 525 526 ret = intel_dp_hdcp2_wait_for_msg(connector, hdcp2_msg_data); 527 if (ret < 0) 528 return ret; 529 530 hdcp->cp_irq_count_cached = atomic_read(&hdcp->cp_irq_count); 531 532 /* DP adaptation msgs has no msg_id */ 533 byte++; 534 535 if (msg_id == HDCP_2_2_REP_SEND_RECVID_LIST) { 536 ret = get_receiver_id_list_rx_info(connector, &dev_cnt, byte); 537 if (ret < 0) 538 return ret; 539 540 byte += ret; 541 size = sizeof(struct hdcp2_rep_send_receiverid_list) - 542 HDCP_2_2_RXINFO_LEN - HDCP_2_2_RECEIVER_IDS_MAX_LEN + 543 (dev_cnt * HDCP_2_2_RECEIVER_ID_LEN); 544 offset += HDCP_2_2_RXINFO_LEN; 545 } 546 547 bytes_to_recv = size - 1; 548 549 while (bytes_to_recv) { 550 len = bytes_to_recv > DP_AUX_MAX_PAYLOAD_BYTES ? 551 DP_AUX_MAX_PAYLOAD_BYTES : bytes_to_recv; 552 553 /* Entire msg read timeout since initiate of msg read */ 554 if (bytes_to_recv == size - 1 && hdcp2_msg_data->msg_read_timeout > 0) { 555 msg_end = ktime_add_ms(ktime_get_raw(), 556 hdcp2_msg_data->msg_read_timeout); 557 } 558 559 ret = drm_dp_dpcd_read(aux, offset, 560 (void *)byte, len); 561 if (ret < 0) { 562 drm_dbg_kms(&i915->drm, "msg_id %d, ret %zd\n", 563 msg_id, ret); 564 return ret; 565 } 566 567 bytes_to_recv -= ret; 568 byte += ret; 569 offset += ret; 570 } 571 572 if (hdcp2_msg_data->msg_read_timeout > 0) { 573 msg_expired = ktime_after(ktime_get_raw(), msg_end); 574 if (msg_expired) { 575 drm_dbg_kms(&i915->drm, "msg_id %d, entire msg read timeout(mSec): %d\n", 576 msg_id, hdcp2_msg_data->msg_read_timeout); 577 return -ETIMEDOUT; 578 } 579 } 580 581 byte = buf; 582 *byte = msg_id; 583 584 return size; 585 } 586 587 static 588 int intel_dp_hdcp2_config_stream_type(struct intel_connector *connector, 589 bool is_repeater, u8 content_type) 590 { 591 int ret; 592 struct hdcp2_dp_errata_stream_type stream_type_msg; 593 594 if (is_repeater) 595 return 0; 596 597 /* 598 * Errata for DP: As Stream type is used for encryption, Receiver 599 * should be communicated with stream type for the decryption of the 600 * content. 601 * Repeater will be communicated with stream type as a part of it's 602 * auth later in time. 603 */ 604 stream_type_msg.msg_id = HDCP_2_2_ERRATA_DP_STREAM_TYPE; 605 stream_type_msg.stream_type = content_type; 606 607 ret = intel_dp_hdcp2_write_msg(connector, &stream_type_msg, 608 sizeof(stream_type_msg)); 609 610 return ret < 0 ? ret : 0; 611 612 } 613 614 static 615 int intel_dp_hdcp2_check_link(struct intel_digital_port *dig_port, 616 struct intel_connector *connector) 617 { 618 u8 rx_status; 619 int ret; 620 621 ret = intel_dp_hdcp2_read_rx_status(connector, 622 &rx_status); 623 if (ret) 624 return ret; 625 626 if (HDCP_2_2_DP_RXSTATUS_REAUTH_REQ(rx_status)) 627 ret = HDCP_REAUTH_REQUEST; 628 else if (HDCP_2_2_DP_RXSTATUS_LINK_FAILED(rx_status)) 629 ret = HDCP_LINK_INTEGRITY_FAILURE; 630 else if (HDCP_2_2_DP_RXSTATUS_READY(rx_status)) 631 ret = HDCP_TOPOLOGY_CHANGE; 632 633 return ret; 634 } 635 636 static 637 int intel_dp_hdcp2_capable(struct intel_connector *connector, 638 bool *capable) 639 { 640 struct intel_digital_port *dig_port = intel_attached_dig_port(connector); 641 struct drm_dp_aux *aux = &dig_port->dp.aux; 642 u8 rx_caps[3]; 643 int ret; 644 645 *capable = false; 646 ret = drm_dp_dpcd_read(aux, 647 DP_HDCP_2_2_REG_RX_CAPS_OFFSET, 648 rx_caps, HDCP_2_2_RXCAPS_LEN); 649 if (ret != HDCP_2_2_RXCAPS_LEN) 650 return ret >= 0 ? -EIO : ret; 651 652 if (rx_caps[0] == HDCP_2_2_RX_CAPS_VERSION_VAL && 653 HDCP_2_2_DP_HDCP_CAPABLE(rx_caps[2])) 654 *capable = true; 655 656 return 0; 657 } 658 659 static const struct intel_hdcp_shim intel_dp_hdcp_shim = { 660 .write_an_aksv = intel_dp_hdcp_write_an_aksv, 661 .read_bksv = intel_dp_hdcp_read_bksv, 662 .read_bstatus = intel_dp_hdcp_read_bstatus, 663 .repeater_present = intel_dp_hdcp_repeater_present, 664 .read_ri_prime = intel_dp_hdcp_read_ri_prime, 665 .read_ksv_ready = intel_dp_hdcp_read_ksv_ready, 666 .read_ksv_fifo = intel_dp_hdcp_read_ksv_fifo, 667 .read_v_prime_part = intel_dp_hdcp_read_v_prime_part, 668 .toggle_signalling = intel_dp_hdcp_toggle_signalling, 669 .check_link = intel_dp_hdcp_check_link, 670 .hdcp_capable = intel_dp_hdcp_capable, 671 .write_2_2_msg = intel_dp_hdcp2_write_msg, 672 .read_2_2_msg = intel_dp_hdcp2_read_msg, 673 .config_stream_type = intel_dp_hdcp2_config_stream_type, 674 .check_2_2_link = intel_dp_hdcp2_check_link, 675 .hdcp_2_2_capable = intel_dp_hdcp2_capable, 676 .protocol = HDCP_PROTOCOL_DP, 677 }; 678 679 static int 680 intel_dp_mst_toggle_hdcp_stream_select(struct intel_connector *connector, 681 bool enable) 682 { 683 struct intel_digital_port *dig_port = intel_attached_dig_port(connector); 684 struct drm_i915_private *i915 = to_i915(connector->base.dev); 685 struct intel_hdcp *hdcp = &connector->hdcp; 686 int ret; 687 688 ret = intel_ddi_toggle_hdcp_bits(&dig_port->base, 689 hdcp->stream_transcoder, enable, 690 TRANS_DDI_HDCP_SELECT); 691 if (ret) 692 drm_err(&i915->drm, "%s HDCP stream select failed (%d)\n", 693 enable ? "Enable" : "Disable", ret); 694 return ret; 695 } 696 697 static int 698 intel_dp_mst_hdcp_stream_encryption(struct intel_connector *connector, 699 bool enable) 700 { 701 struct intel_digital_port *dig_port = intel_attached_dig_port(connector); 702 struct drm_i915_private *i915 = to_i915(connector->base.dev); 703 struct intel_hdcp *hdcp = &connector->hdcp; 704 enum port port = dig_port->base.port; 705 enum transcoder cpu_transcoder = hdcp->stream_transcoder; 706 u32 stream_enc_status; 707 int ret; 708 709 ret = intel_dp_mst_toggle_hdcp_stream_select(connector, enable); 710 if (ret) 711 return ret; 712 713 stream_enc_status = transcoder_to_stream_enc_status(cpu_transcoder); 714 if (!stream_enc_status) 715 return -EINVAL; 716 717 /* Wait for encryption confirmation */ 718 if (intel_de_wait_for_register(i915, 719 HDCP_STATUS(i915, cpu_transcoder, port), 720 stream_enc_status, 721 enable ? stream_enc_status : 0, 722 HDCP_ENCRYPT_STATUS_CHANGE_TIMEOUT_MS)) { 723 drm_err(&i915->drm, "Timed out waiting for transcoder: %s stream encryption %s\n", 724 transcoder_name(cpu_transcoder), enable ? "enabled" : "disabled"); 725 return -ETIMEDOUT; 726 } 727 728 return 0; 729 } 730 731 static int 732 intel_dp_mst_hdcp2_stream_encryption(struct intel_connector *connector, 733 bool enable) 734 { 735 struct intel_digital_port *dig_port = intel_attached_dig_port(connector); 736 struct drm_i915_private *i915 = to_i915(connector->base.dev); 737 struct hdcp_port_data *data = &dig_port->hdcp_port_data; 738 struct intel_hdcp *hdcp = &connector->hdcp; 739 enum transcoder cpu_transcoder = hdcp->stream_transcoder; 740 enum pipe pipe = (enum pipe)cpu_transcoder; 741 enum port port = dig_port->base.port; 742 int ret; 743 744 drm_WARN_ON(&i915->drm, enable && 745 !!(intel_de_read(i915, HDCP2_AUTH_STREAM(i915, cpu_transcoder, port)) 746 & AUTH_STREAM_TYPE) != data->streams[0].stream_type); 747 748 ret = intel_dp_mst_toggle_hdcp_stream_select(connector, enable); 749 if (ret) 750 return ret; 751 752 /* Wait for encryption confirmation */ 753 if (intel_de_wait_for_register(i915, 754 HDCP2_STREAM_STATUS(i915, cpu_transcoder, pipe), 755 STREAM_ENCRYPTION_STATUS, 756 enable ? STREAM_ENCRYPTION_STATUS : 0, 757 HDCP_ENCRYPT_STATUS_CHANGE_TIMEOUT_MS)) { 758 drm_err(&i915->drm, "Timed out waiting for transcoder: %s stream encryption %s\n", 759 transcoder_name(cpu_transcoder), enable ? "enabled" : "disabled"); 760 return -ETIMEDOUT; 761 } 762 763 return 0; 764 } 765 766 static 767 int intel_dp_mst_hdcp2_check_link(struct intel_digital_port *dig_port, 768 struct intel_connector *connector) 769 { 770 struct intel_hdcp *hdcp = &connector->hdcp; 771 int ret; 772 773 /* 774 * We do need to do the Link Check only for the connector involved with 775 * HDCP port authentication and encryption. 776 * We can re-use the hdcp->is_repeater flag to know that the connector 777 * involved with HDCP port authentication and encryption. 778 */ 779 if (hdcp->is_repeater) { 780 ret = intel_dp_hdcp2_check_link(dig_port, connector); 781 if (ret) 782 return ret; 783 } 784 785 return 0; 786 } 787 788 static const struct intel_hdcp_shim intel_dp_mst_hdcp_shim = { 789 .write_an_aksv = intel_dp_hdcp_write_an_aksv, 790 .read_bksv = intel_dp_hdcp_read_bksv, 791 .read_bstatus = intel_dp_hdcp_read_bstatus, 792 .repeater_present = intel_dp_hdcp_repeater_present, 793 .read_ri_prime = intel_dp_hdcp_read_ri_prime, 794 .read_ksv_ready = intel_dp_hdcp_read_ksv_ready, 795 .read_ksv_fifo = intel_dp_hdcp_read_ksv_fifo, 796 .read_v_prime_part = intel_dp_hdcp_read_v_prime_part, 797 .toggle_signalling = intel_dp_hdcp_toggle_signalling, 798 .stream_encryption = intel_dp_mst_hdcp_stream_encryption, 799 .check_link = intel_dp_hdcp_check_link, 800 .hdcp_capable = intel_dp_hdcp_capable, 801 .write_2_2_msg = intel_dp_hdcp2_write_msg, 802 .read_2_2_msg = intel_dp_hdcp2_read_msg, 803 .config_stream_type = intel_dp_hdcp2_config_stream_type, 804 .stream_2_2_encryption = intel_dp_mst_hdcp2_stream_encryption, 805 .check_2_2_link = intel_dp_mst_hdcp2_check_link, 806 .hdcp_2_2_capable = intel_dp_hdcp2_capable, 807 .protocol = HDCP_PROTOCOL_DP, 808 }; 809 810 int intel_dp_hdcp_init(struct intel_digital_port *dig_port, 811 struct intel_connector *intel_connector) 812 { 813 struct drm_device *dev = intel_connector->base.dev; 814 struct drm_i915_private *dev_priv = to_i915(dev); 815 struct intel_encoder *intel_encoder = &dig_port->base; 816 enum port port = intel_encoder->port; 817 struct intel_dp *intel_dp = &dig_port->dp; 818 819 if (!is_hdcp_supported(dev_priv, port)) 820 return 0; 821 822 if (intel_connector->mst_port) 823 return intel_hdcp_init(intel_connector, dig_port, 824 &intel_dp_mst_hdcp_shim); 825 else if (!intel_dp_is_edp(intel_dp)) 826 return intel_hdcp_init(intel_connector, dig_port, 827 &intel_dp_hdcp_shim); 828 829 return 0; 830 } 831