1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2012-2020, The Linux Foundation. All rights reserved. 4 */ 5 6 #define pr_fmt(fmt) "[drm-dp] %s: " fmt, __func__ 7 8 #include <drm/drm_print.h> 9 10 #include "dp_link.h" 11 #include "dp_panel.h" 12 13 #define DP_TEST_REQUEST_MASK 0x7F 14 15 enum audio_sample_rate { 16 AUDIO_SAMPLE_RATE_32_KHZ = 0x00, 17 AUDIO_SAMPLE_RATE_44_1_KHZ = 0x01, 18 AUDIO_SAMPLE_RATE_48_KHZ = 0x02, 19 AUDIO_SAMPLE_RATE_88_2_KHZ = 0x03, 20 AUDIO_SAMPLE_RATE_96_KHZ = 0x04, 21 AUDIO_SAMPLE_RATE_176_4_KHZ = 0x05, 22 AUDIO_SAMPLE_RATE_192_KHZ = 0x06, 23 }; 24 25 enum audio_pattern_type { 26 AUDIO_TEST_PATTERN_OPERATOR_DEFINED = 0x00, 27 AUDIO_TEST_PATTERN_SAWTOOTH = 0x01, 28 }; 29 30 struct dp_link_request { 31 u32 test_requested; 32 u32 test_link_rate; 33 u32 test_lane_count; 34 }; 35 36 struct dp_link_private { 37 u32 prev_sink_count; 38 struct device *dev; 39 struct drm_device *drm_dev; 40 struct drm_dp_aux *aux; 41 struct dp_link dp_link; 42 43 struct dp_link_request request; 44 struct mutex psm_mutex; 45 u8 link_status[DP_LINK_STATUS_SIZE]; 46 }; 47 48 static int dp_aux_link_power_up(struct drm_dp_aux *aux, 49 struct dp_link_info *link) 50 { 51 u8 value; 52 ssize_t len; 53 int i; 54 55 if (link->revision < 0x11) 56 return 0; 57 58 len = drm_dp_dpcd_readb(aux, DP_SET_POWER, &value); 59 if (len < 0) 60 return len; 61 62 value &= ~DP_SET_POWER_MASK; 63 value |= DP_SET_POWER_D0; 64 65 /* retry for 1ms to give the sink time to wake up */ 66 for (i = 0; i < 3; i++) { 67 len = drm_dp_dpcd_writeb(aux, DP_SET_POWER, value); 68 usleep_range(1000, 2000); 69 if (len == 1) 70 break; 71 } 72 73 return 0; 74 } 75 76 static int dp_aux_link_power_down(struct drm_dp_aux *aux, 77 struct dp_link_info *link) 78 { 79 u8 value; 80 int err; 81 82 if (link->revision < 0x11) 83 return 0; 84 85 err = drm_dp_dpcd_readb(aux, DP_SET_POWER, &value); 86 if (err < 0) 87 return err; 88 89 value &= ~DP_SET_POWER_MASK; 90 value |= DP_SET_POWER_D3; 91 92 err = drm_dp_dpcd_writeb(aux, DP_SET_POWER, value); 93 if (err < 0) 94 return err; 95 96 return 0; 97 } 98 99 static int dp_link_get_period(struct dp_link_private *link, int const addr) 100 { 101 int ret = 0; 102 u8 data; 103 u32 const max_audio_period = 0xA; 104 105 /* TEST_AUDIO_PERIOD_CH_XX */ 106 if (drm_dp_dpcd_readb(link->aux, addr, &data) < 0) { 107 DRM_ERROR("failed to read test_audio_period (0x%x)\n", addr); 108 ret = -EINVAL; 109 goto exit; 110 } 111 112 /* Period - Bits 3:0 */ 113 data = data & 0xF; 114 if ((int)data > max_audio_period) { 115 DRM_ERROR("invalid test_audio_period_ch_1 = 0x%x\n", data); 116 ret = -EINVAL; 117 goto exit; 118 } 119 120 ret = data; 121 exit: 122 return ret; 123 } 124 125 static int dp_link_parse_audio_channel_period(struct dp_link_private *link) 126 { 127 int ret = 0; 128 struct dp_link_test_audio *req = &link->dp_link.test_audio; 129 130 ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH1); 131 if (ret == -EINVAL) 132 goto exit; 133 134 req->test_audio_period_ch_1 = ret; 135 drm_dbg_dp(link->drm_dev, "test_audio_period_ch_1 = 0x%x\n", ret); 136 137 ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH2); 138 if (ret == -EINVAL) 139 goto exit; 140 141 req->test_audio_period_ch_2 = ret; 142 drm_dbg_dp(link->drm_dev, "test_audio_period_ch_2 = 0x%x\n", ret); 143 144 /* TEST_AUDIO_PERIOD_CH_3 (Byte 0x275) */ 145 ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH3); 146 if (ret == -EINVAL) 147 goto exit; 148 149 req->test_audio_period_ch_3 = ret; 150 drm_dbg_dp(link->drm_dev, "test_audio_period_ch_3 = 0x%x\n", ret); 151 152 ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH4); 153 if (ret == -EINVAL) 154 goto exit; 155 156 req->test_audio_period_ch_4 = ret; 157 drm_dbg_dp(link->drm_dev, "test_audio_period_ch_4 = 0x%x\n", ret); 158 159 ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH5); 160 if (ret == -EINVAL) 161 goto exit; 162 163 req->test_audio_period_ch_5 = ret; 164 drm_dbg_dp(link->drm_dev, "test_audio_period_ch_5 = 0x%x\n", ret); 165 166 ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH6); 167 if (ret == -EINVAL) 168 goto exit; 169 170 req->test_audio_period_ch_6 = ret; 171 drm_dbg_dp(link->drm_dev, "test_audio_period_ch_6 = 0x%x\n", ret); 172 173 ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH7); 174 if (ret == -EINVAL) 175 goto exit; 176 177 req->test_audio_period_ch_7 = ret; 178 drm_dbg_dp(link->drm_dev, "test_audio_period_ch_7 = 0x%x\n", ret); 179 180 ret = dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH8); 181 if (ret == -EINVAL) 182 goto exit; 183 184 req->test_audio_period_ch_8 = ret; 185 drm_dbg_dp(link->drm_dev, "test_audio_period_ch_8 = 0x%x\n", ret); 186 exit: 187 return ret; 188 } 189 190 static int dp_link_parse_audio_pattern_type(struct dp_link_private *link) 191 { 192 int ret = 0; 193 u8 data; 194 ssize_t rlen; 195 int const max_audio_pattern_type = 0x1; 196 197 rlen = drm_dp_dpcd_readb(link->aux, 198 DP_TEST_AUDIO_PATTERN_TYPE, &data); 199 if (rlen < 0) { 200 DRM_ERROR("failed to read link audio mode. rlen=%zd\n", rlen); 201 return rlen; 202 } 203 204 /* Audio Pattern Type - Bits 7:0 */ 205 if ((int)data > max_audio_pattern_type) { 206 DRM_ERROR("invalid audio pattern type = 0x%x\n", data); 207 ret = -EINVAL; 208 goto exit; 209 } 210 211 link->dp_link.test_audio.test_audio_pattern_type = data; 212 drm_dbg_dp(link->drm_dev, "audio pattern type = 0x%x\n", data); 213 exit: 214 return ret; 215 } 216 217 static int dp_link_parse_audio_mode(struct dp_link_private *link) 218 { 219 int ret = 0; 220 u8 data; 221 ssize_t rlen; 222 int const max_audio_sampling_rate = 0x6; 223 int const max_audio_channel_count = 0x8; 224 int sampling_rate = 0x0; 225 int channel_count = 0x0; 226 227 rlen = drm_dp_dpcd_readb(link->aux, DP_TEST_AUDIO_MODE, &data); 228 if (rlen < 0) { 229 DRM_ERROR("failed to read link audio mode. rlen=%zd\n", rlen); 230 return rlen; 231 } 232 233 /* Sampling Rate - Bits 3:0 */ 234 sampling_rate = data & 0xF; 235 if (sampling_rate > max_audio_sampling_rate) { 236 DRM_ERROR("sampling rate (0x%x) greater than max (0x%x)\n", 237 sampling_rate, max_audio_sampling_rate); 238 ret = -EINVAL; 239 goto exit; 240 } 241 242 /* Channel Count - Bits 7:4 */ 243 channel_count = ((data & 0xF0) >> 4) + 1; 244 if (channel_count > max_audio_channel_count) { 245 DRM_ERROR("channel_count (0x%x) greater than max (0x%x)\n", 246 channel_count, max_audio_channel_count); 247 ret = -EINVAL; 248 goto exit; 249 } 250 251 link->dp_link.test_audio.test_audio_sampling_rate = sampling_rate; 252 link->dp_link.test_audio.test_audio_channel_count = channel_count; 253 drm_dbg_dp(link->drm_dev, 254 "sampling_rate = 0x%x, channel_count = 0x%x\n", 255 sampling_rate, channel_count); 256 exit: 257 return ret; 258 } 259 260 static int dp_link_parse_audio_pattern_params(struct dp_link_private *link) 261 { 262 int ret = 0; 263 264 ret = dp_link_parse_audio_mode(link); 265 if (ret) 266 goto exit; 267 268 ret = dp_link_parse_audio_pattern_type(link); 269 if (ret) 270 goto exit; 271 272 ret = dp_link_parse_audio_channel_period(link); 273 274 exit: 275 return ret; 276 } 277 278 static bool dp_link_is_video_pattern_valid(u32 pattern) 279 { 280 switch (pattern) { 281 case DP_NO_TEST_PATTERN: 282 case DP_COLOR_RAMP: 283 case DP_BLACK_AND_WHITE_VERTICAL_LINES: 284 case DP_COLOR_SQUARE: 285 return true; 286 default: 287 return false; 288 } 289 } 290 291 /** 292 * dp_link_is_bit_depth_valid() - validates the bit depth requested 293 * @tbd: bit depth requested by the sink 294 * 295 * Returns true if the requested bit depth is supported. 296 */ 297 static bool dp_link_is_bit_depth_valid(u32 tbd) 298 { 299 /* DP_TEST_VIDEO_PATTERN_NONE is treated as invalid */ 300 switch (tbd) { 301 case DP_TEST_BIT_DEPTH_6: 302 case DP_TEST_BIT_DEPTH_8: 303 case DP_TEST_BIT_DEPTH_10: 304 return true; 305 default: 306 return false; 307 } 308 } 309 310 static int dp_link_parse_timing_params1(struct dp_link_private *link, 311 int addr, int len, u32 *val) 312 { 313 u8 bp[2]; 314 int rlen; 315 316 if (len != 2) 317 return -EINVAL; 318 319 /* Read the requested video link pattern (Byte 0x221). */ 320 rlen = drm_dp_dpcd_read(link->aux, addr, bp, len); 321 if (rlen < len) { 322 DRM_ERROR("failed to read 0x%x\n", addr); 323 return -EINVAL; 324 } 325 326 *val = bp[1] | (bp[0] << 8); 327 328 return 0; 329 } 330 331 static int dp_link_parse_timing_params2(struct dp_link_private *link, 332 int addr, int len, 333 u32 *val1, u32 *val2) 334 { 335 u8 bp[2]; 336 int rlen; 337 338 if (len != 2) 339 return -EINVAL; 340 341 /* Read the requested video link pattern (Byte 0x221). */ 342 rlen = drm_dp_dpcd_read(link->aux, addr, bp, len); 343 if (rlen < len) { 344 DRM_ERROR("failed to read 0x%x\n", addr); 345 return -EINVAL; 346 } 347 348 *val1 = (bp[0] & BIT(7)) >> 7; 349 *val2 = bp[1] | ((bp[0] & 0x7F) << 8); 350 351 return 0; 352 } 353 354 static int dp_link_parse_timing_params3(struct dp_link_private *link, 355 int addr, u32 *val) 356 { 357 u8 bp; 358 u32 len = 1; 359 int rlen; 360 361 rlen = drm_dp_dpcd_read(link->aux, addr, &bp, len); 362 if (rlen < 1) { 363 DRM_ERROR("failed to read 0x%x\n", addr); 364 return -EINVAL; 365 } 366 *val = bp; 367 368 return 0; 369 } 370 371 /** 372 * dp_link_parse_video_pattern_params() - parses video pattern parameters from DPCD 373 * @link: Display Port Driver data 374 * 375 * Returns 0 if it successfully parses the video link pattern and the link 376 * bit depth requested by the sink and, and if the values parsed are valid. 377 */ 378 static int dp_link_parse_video_pattern_params(struct dp_link_private *link) 379 { 380 int ret = 0; 381 ssize_t rlen; 382 u8 bp; 383 384 rlen = drm_dp_dpcd_readb(link->aux, DP_TEST_PATTERN, &bp); 385 if (rlen < 0) { 386 DRM_ERROR("failed to read link video pattern. rlen=%zd\n", 387 rlen); 388 return rlen; 389 } 390 391 if (!dp_link_is_video_pattern_valid(bp)) { 392 DRM_ERROR("invalid link video pattern = 0x%x\n", bp); 393 ret = -EINVAL; 394 return ret; 395 } 396 397 link->dp_link.test_video.test_video_pattern = bp; 398 399 /* Read the requested color bit depth and dynamic range (Byte 0x232) */ 400 rlen = drm_dp_dpcd_readb(link->aux, DP_TEST_MISC0, &bp); 401 if (rlen < 0) { 402 DRM_ERROR("failed to read link bit depth. rlen=%zd\n", rlen); 403 return rlen; 404 } 405 406 /* Dynamic Range */ 407 link->dp_link.test_video.test_dyn_range = 408 (bp & DP_TEST_DYNAMIC_RANGE_CEA); 409 410 /* Color bit depth */ 411 bp &= DP_TEST_BIT_DEPTH_MASK; 412 if (!dp_link_is_bit_depth_valid(bp)) { 413 DRM_ERROR("invalid link bit depth = 0x%x\n", bp); 414 ret = -EINVAL; 415 return ret; 416 } 417 418 link->dp_link.test_video.test_bit_depth = bp; 419 420 /* resolution timing params */ 421 ret = dp_link_parse_timing_params1(link, DP_TEST_H_TOTAL_HI, 2, 422 &link->dp_link.test_video.test_h_total); 423 if (ret) { 424 DRM_ERROR("failed to parse test_htotal(DP_TEST_H_TOTAL_HI)\n"); 425 return ret; 426 } 427 428 ret = dp_link_parse_timing_params1(link, DP_TEST_V_TOTAL_HI, 2, 429 &link->dp_link.test_video.test_v_total); 430 if (ret) { 431 DRM_ERROR("failed to parse test_v_total(DP_TEST_V_TOTAL_HI)\n"); 432 return ret; 433 } 434 435 ret = dp_link_parse_timing_params1(link, DP_TEST_H_START_HI, 2, 436 &link->dp_link.test_video.test_h_start); 437 if (ret) { 438 DRM_ERROR("failed to parse test_h_start(DP_TEST_H_START_HI)\n"); 439 return ret; 440 } 441 442 ret = dp_link_parse_timing_params1(link, DP_TEST_V_START_HI, 2, 443 &link->dp_link.test_video.test_v_start); 444 if (ret) { 445 DRM_ERROR("failed to parse test_v_start(DP_TEST_V_START_HI)\n"); 446 return ret; 447 } 448 449 ret = dp_link_parse_timing_params2(link, DP_TEST_HSYNC_HI, 2, 450 &link->dp_link.test_video.test_hsync_pol, 451 &link->dp_link.test_video.test_hsync_width); 452 if (ret) { 453 DRM_ERROR("failed to parse (DP_TEST_HSYNC_HI)\n"); 454 return ret; 455 } 456 457 ret = dp_link_parse_timing_params2(link, DP_TEST_VSYNC_HI, 2, 458 &link->dp_link.test_video.test_vsync_pol, 459 &link->dp_link.test_video.test_vsync_width); 460 if (ret) { 461 DRM_ERROR("failed to parse (DP_TEST_VSYNC_HI)\n"); 462 return ret; 463 } 464 465 ret = dp_link_parse_timing_params1(link, DP_TEST_H_WIDTH_HI, 2, 466 &link->dp_link.test_video.test_h_width); 467 if (ret) { 468 DRM_ERROR("failed to parse test_h_width(DP_TEST_H_WIDTH_HI)\n"); 469 return ret; 470 } 471 472 ret = dp_link_parse_timing_params1(link, DP_TEST_V_HEIGHT_HI, 2, 473 &link->dp_link.test_video.test_v_height); 474 if (ret) { 475 DRM_ERROR("failed to parse test_v_height\n"); 476 return ret; 477 } 478 479 ret = dp_link_parse_timing_params3(link, DP_TEST_MISC1, 480 &link->dp_link.test_video.test_rr_d); 481 link->dp_link.test_video.test_rr_d &= DP_TEST_REFRESH_DENOMINATOR; 482 if (ret) { 483 DRM_ERROR("failed to parse test_rr_d (DP_TEST_MISC1)\n"); 484 return ret; 485 } 486 487 ret = dp_link_parse_timing_params3(link, DP_TEST_REFRESH_RATE_NUMERATOR, 488 &link->dp_link.test_video.test_rr_n); 489 if (ret) { 490 DRM_ERROR("failed to parse test_rr_n\n"); 491 return ret; 492 } 493 494 drm_dbg_dp(link->drm_dev, 495 "link video pattern = 0x%x\n" 496 "link dynamic range = 0x%x\n" 497 "link bit depth = 0x%x\n" 498 "TEST_H_TOTAL = %d, TEST_V_TOTAL = %d\n" 499 "TEST_H_START = %d, TEST_V_START = %d\n" 500 "TEST_HSYNC_POL = %d\n" 501 "TEST_HSYNC_WIDTH = %d\n" 502 "TEST_VSYNC_POL = %d\n" 503 "TEST_VSYNC_WIDTH = %d\n" 504 "TEST_H_WIDTH = %d\n" 505 "TEST_V_HEIGHT = %d\n" 506 "TEST_REFRESH_DENOMINATOR = %d\n" 507 "TEST_REFRESH_NUMERATOR = %d\n", 508 link->dp_link.test_video.test_video_pattern, 509 link->dp_link.test_video.test_dyn_range, 510 link->dp_link.test_video.test_bit_depth, 511 link->dp_link.test_video.test_h_total, 512 link->dp_link.test_video.test_v_total, 513 link->dp_link.test_video.test_h_start, 514 link->dp_link.test_video.test_v_start, 515 link->dp_link.test_video.test_hsync_pol, 516 link->dp_link.test_video.test_hsync_width, 517 link->dp_link.test_video.test_vsync_pol, 518 link->dp_link.test_video.test_vsync_width, 519 link->dp_link.test_video.test_h_width, 520 link->dp_link.test_video.test_v_height, 521 link->dp_link.test_video.test_rr_d, 522 link->dp_link.test_video.test_rr_n); 523 524 return ret; 525 } 526 527 /** 528 * dp_link_parse_link_training_params() - parses link training parameters from 529 * DPCD 530 * @link: Display Port Driver data 531 * 532 * Returns 0 if it successfully parses the link rate (Byte 0x219) and lane 533 * count (Byte 0x220), and if these values parse are valid. 534 */ 535 static int dp_link_parse_link_training_params(struct dp_link_private *link) 536 { 537 u8 bp; 538 ssize_t rlen; 539 540 rlen = drm_dp_dpcd_readb(link->aux, DP_TEST_LINK_RATE, &bp); 541 if (rlen < 0) { 542 DRM_ERROR("failed to read link rate. rlen=%zd\n", rlen); 543 return rlen; 544 } 545 546 if (!is_link_rate_valid(bp)) { 547 DRM_ERROR("invalid link rate = 0x%x\n", bp); 548 return -EINVAL; 549 } 550 551 link->request.test_link_rate = bp; 552 drm_dbg_dp(link->drm_dev, "link rate = 0x%x\n", 553 link->request.test_link_rate); 554 555 rlen = drm_dp_dpcd_readb(link->aux, DP_TEST_LANE_COUNT, &bp); 556 if (rlen < 0) { 557 DRM_ERROR("failed to read lane count. rlen=%zd\n", rlen); 558 return rlen; 559 } 560 bp &= DP_MAX_LANE_COUNT_MASK; 561 562 if (!is_lane_count_valid(bp)) { 563 DRM_ERROR("invalid lane count = 0x%x\n", bp); 564 return -EINVAL; 565 } 566 567 link->request.test_lane_count = bp; 568 drm_dbg_dp(link->drm_dev, "lane count = 0x%x\n", 569 link->request.test_lane_count); 570 return 0; 571 } 572 573 /** 574 * dp_link_parse_phy_test_params() - parses the phy link parameters 575 * @link: Display Port Driver data 576 * 577 * Parses the DPCD (Byte 0x248) for the DP PHY link pattern that is being 578 * requested. 579 */ 580 static int dp_link_parse_phy_test_params(struct dp_link_private *link) 581 { 582 u8 data; 583 ssize_t rlen; 584 585 rlen = drm_dp_dpcd_readb(link->aux, DP_PHY_TEST_PATTERN, 586 &data); 587 if (rlen < 0) { 588 DRM_ERROR("failed to read phy link pattern. rlen=%zd\n", rlen); 589 return rlen; 590 } 591 592 link->dp_link.phy_params.phy_test_pattern_sel = data & 0x07; 593 594 drm_dbg_dp(link->drm_dev, "phy_test_pattern_sel = 0x%x\n", data); 595 596 switch (data) { 597 case DP_PHY_TEST_PATTERN_SEL_MASK: 598 case DP_PHY_TEST_PATTERN_NONE: 599 case DP_PHY_TEST_PATTERN_D10_2: 600 case DP_PHY_TEST_PATTERN_ERROR_COUNT: 601 case DP_PHY_TEST_PATTERN_PRBS7: 602 case DP_PHY_TEST_PATTERN_80BIT_CUSTOM: 603 case DP_PHY_TEST_PATTERN_CP2520: 604 return 0; 605 default: 606 return -EINVAL; 607 } 608 } 609 610 /** 611 * dp_link_is_video_audio_test_requested() - checks for audio/video link request 612 * @link: link requested by the sink 613 * 614 * Returns true if the requested link is a permitted audio/video link. 615 */ 616 static bool dp_link_is_video_audio_test_requested(u32 link) 617 { 618 u8 video_audio_test = (DP_TEST_LINK_VIDEO_PATTERN | 619 DP_TEST_LINK_AUDIO_PATTERN | 620 DP_TEST_LINK_AUDIO_DISABLED_VIDEO); 621 622 return ((link & video_audio_test) && 623 !(link & ~video_audio_test)); 624 } 625 626 /** 627 * dp_link_parse_request() - parses link request parameters from sink 628 * @link: Display Port Driver data 629 * 630 * Parses the DPCD to check if an automated link is requested (Byte 0x201), 631 * and what type of link automation is being requested (Byte 0x218). 632 */ 633 static int dp_link_parse_request(struct dp_link_private *link) 634 { 635 int ret = 0; 636 u8 data; 637 ssize_t rlen; 638 639 /** 640 * Read the device service IRQ vector (Byte 0x201) to determine 641 * whether an automated link has been requested by the sink. 642 */ 643 rlen = drm_dp_dpcd_readb(link->aux, 644 DP_DEVICE_SERVICE_IRQ_VECTOR, &data); 645 if (rlen < 0) { 646 DRM_ERROR("aux read failed. rlen=%zd\n", rlen); 647 return rlen; 648 } 649 650 drm_dbg_dp(link->drm_dev, "device service irq vector = 0x%x\n", data); 651 652 if (!(data & DP_AUTOMATED_TEST_REQUEST)) { 653 drm_dbg_dp(link->drm_dev, "no test requested\n"); 654 return 0; 655 } 656 657 /** 658 * Read the link request byte (Byte 0x218) to determine what type 659 * of automated link has been requested by the sink. 660 */ 661 rlen = drm_dp_dpcd_readb(link->aux, DP_TEST_REQUEST, &data); 662 if (rlen < 0) { 663 DRM_ERROR("aux read failed. rlen=%zd\n", rlen); 664 return rlen; 665 } 666 667 if (!data || (data == DP_TEST_LINK_FAUX_PATTERN)) { 668 drm_dbg_dp(link->drm_dev, "link 0x%x not supported\n", data); 669 goto end; 670 } 671 672 drm_dbg_dp(link->drm_dev, "Test:(0x%x) requested\n", data); 673 link->request.test_requested = data; 674 if (link->request.test_requested == DP_TEST_LINK_PHY_TEST_PATTERN) { 675 ret = dp_link_parse_phy_test_params(link); 676 if (ret) 677 goto end; 678 ret = dp_link_parse_link_training_params(link); 679 if (ret) 680 goto end; 681 } 682 683 if (link->request.test_requested == DP_TEST_LINK_TRAINING) { 684 ret = dp_link_parse_link_training_params(link); 685 if (ret) 686 goto end; 687 } 688 689 if (dp_link_is_video_audio_test_requested( 690 link->request.test_requested)) { 691 ret = dp_link_parse_video_pattern_params(link); 692 if (ret) 693 goto end; 694 695 ret = dp_link_parse_audio_pattern_params(link); 696 } 697 end: 698 /* 699 * Send a DP_TEST_ACK if all link parameters are valid, otherwise send 700 * a DP_TEST_NAK. 701 */ 702 if (ret) { 703 link->dp_link.test_response = DP_TEST_NAK; 704 } else { 705 if (link->request.test_requested != DP_TEST_LINK_EDID_READ) 706 link->dp_link.test_response = DP_TEST_ACK; 707 else 708 link->dp_link.test_response = 709 DP_TEST_EDID_CHECKSUM_WRITE; 710 } 711 712 return ret; 713 } 714 715 /** 716 * dp_link_parse_sink_count() - parses the sink count 717 * @dp_link: pointer to link module data 718 * 719 * Parses the DPCD to check if there is an update to the sink count 720 * (Byte 0x200), and whether all the sink devices connected have Content 721 * Protection enabled. 722 */ 723 static int dp_link_parse_sink_count(struct dp_link *dp_link) 724 { 725 ssize_t rlen; 726 bool cp_ready; 727 728 struct dp_link_private *link = container_of(dp_link, 729 struct dp_link_private, dp_link); 730 731 rlen = drm_dp_dpcd_readb(link->aux, DP_SINK_COUNT, 732 &link->dp_link.sink_count); 733 if (rlen < 0) { 734 DRM_ERROR("sink count read failed. rlen=%zd\n", rlen); 735 return rlen; 736 } 737 738 cp_ready = link->dp_link.sink_count & DP_SINK_CP_READY; 739 740 link->dp_link.sink_count = 741 DP_GET_SINK_COUNT(link->dp_link.sink_count); 742 743 drm_dbg_dp(link->drm_dev, "sink_count = 0x%x, cp_ready = 0x%x\n", 744 link->dp_link.sink_count, cp_ready); 745 return 0; 746 } 747 748 static int dp_link_parse_sink_status_field(struct dp_link_private *link) 749 { 750 int len = 0; 751 752 link->prev_sink_count = link->dp_link.sink_count; 753 len = dp_link_parse_sink_count(&link->dp_link); 754 if (len < 0) { 755 DRM_ERROR("DP parse sink count failed\n"); 756 return len; 757 } 758 759 len = drm_dp_dpcd_read_link_status(link->aux, 760 link->link_status); 761 if (len < DP_LINK_STATUS_SIZE) { 762 DRM_ERROR("DP link status read failed\n"); 763 return len; 764 } 765 766 return dp_link_parse_request(link); 767 } 768 769 /** 770 * dp_link_process_link_training_request() - processes new training requests 771 * @link: Display Port link data 772 * 773 * This function will handle new link training requests that are initiated by 774 * the sink. In particular, it will update the requested lane count and link 775 * rate, and then trigger the link retraining procedure. 776 * 777 * The function will return 0 if a link training request has been processed, 778 * otherwise it will return -EINVAL. 779 */ 780 static int dp_link_process_link_training_request(struct dp_link_private *link) 781 { 782 if (link->request.test_requested != DP_TEST_LINK_TRAINING) 783 return -EINVAL; 784 785 drm_dbg_dp(link->drm_dev, 786 "Test:0x%x link rate = 0x%x, lane count = 0x%x\n", 787 DP_TEST_LINK_TRAINING, 788 link->request.test_link_rate, 789 link->request.test_lane_count); 790 791 link->dp_link.link_params.num_lanes = link->request.test_lane_count; 792 link->dp_link.link_params.rate = 793 drm_dp_bw_code_to_link_rate(link->request.test_link_rate); 794 795 return 0; 796 } 797 798 bool dp_link_send_test_response(struct dp_link *dp_link) 799 { 800 struct dp_link_private *link = NULL; 801 int ret = 0; 802 803 if (!dp_link) { 804 DRM_ERROR("invalid input\n"); 805 return false; 806 } 807 808 link = container_of(dp_link, struct dp_link_private, dp_link); 809 810 ret = drm_dp_dpcd_writeb(link->aux, DP_TEST_RESPONSE, 811 dp_link->test_response); 812 813 return ret == 1; 814 } 815 816 int dp_link_psm_config(struct dp_link *dp_link, 817 struct dp_link_info *link_info, bool enable) 818 { 819 struct dp_link_private *link = NULL; 820 int ret = 0; 821 822 if (!dp_link) { 823 DRM_ERROR("invalid params\n"); 824 return -EINVAL; 825 } 826 827 link = container_of(dp_link, struct dp_link_private, dp_link); 828 829 mutex_lock(&link->psm_mutex); 830 if (enable) 831 ret = dp_aux_link_power_down(link->aux, link_info); 832 else 833 ret = dp_aux_link_power_up(link->aux, link_info); 834 835 if (ret) 836 DRM_ERROR("Failed to %s low power mode\n", enable ? 837 "enter" : "exit"); 838 else 839 dp_link->psm_enabled = enable; 840 841 mutex_unlock(&link->psm_mutex); 842 return ret; 843 } 844 845 bool dp_link_send_edid_checksum(struct dp_link *dp_link, u8 checksum) 846 { 847 struct dp_link_private *link = NULL; 848 int ret = 0; 849 850 if (!dp_link) { 851 DRM_ERROR("invalid input\n"); 852 return false; 853 } 854 855 link = container_of(dp_link, struct dp_link_private, dp_link); 856 857 ret = drm_dp_dpcd_writeb(link->aux, DP_TEST_EDID_CHECKSUM, 858 checksum); 859 return ret == 1; 860 } 861 862 static void dp_link_parse_vx_px(struct dp_link_private *link) 863 { 864 drm_dbg_dp(link->drm_dev, "vx: 0=%d, 1=%d, 2=%d, 3=%d\n", 865 drm_dp_get_adjust_request_voltage(link->link_status, 0), 866 drm_dp_get_adjust_request_voltage(link->link_status, 1), 867 drm_dp_get_adjust_request_voltage(link->link_status, 2), 868 drm_dp_get_adjust_request_voltage(link->link_status, 3)); 869 870 drm_dbg_dp(link->drm_dev, "px: 0=%d, 1=%d, 2=%d, 3=%d\n", 871 drm_dp_get_adjust_request_pre_emphasis(link->link_status, 0), 872 drm_dp_get_adjust_request_pre_emphasis(link->link_status, 1), 873 drm_dp_get_adjust_request_pre_emphasis(link->link_status, 2), 874 drm_dp_get_adjust_request_pre_emphasis(link->link_status, 3)); 875 876 /** 877 * Update the voltage and pre-emphasis levels as per DPCD request 878 * vector. 879 */ 880 drm_dbg_dp(link->drm_dev, 881 "Current: v_level = 0x%x, p_level = 0x%x\n", 882 link->dp_link.phy_params.v_level, 883 link->dp_link.phy_params.p_level); 884 link->dp_link.phy_params.v_level = 885 drm_dp_get_adjust_request_voltage(link->link_status, 0); 886 link->dp_link.phy_params.p_level = 887 drm_dp_get_adjust_request_pre_emphasis(link->link_status, 0); 888 889 link->dp_link.phy_params.p_level >>= DP_TRAIN_PRE_EMPHASIS_SHIFT; 890 891 drm_dbg_dp(link->drm_dev, 892 "Requested: v_level = 0x%x, p_level = 0x%x\n", 893 link->dp_link.phy_params.v_level, 894 link->dp_link.phy_params.p_level); 895 } 896 897 /** 898 * dp_link_process_phy_test_pattern_request() - process new phy link requests 899 * @link: Display Port Driver data 900 * 901 * This function will handle new phy link pattern requests that are initiated 902 * by the sink. The function will return 0 if a phy link pattern has been 903 * processed, otherwise it will return -EINVAL. 904 */ 905 static int dp_link_process_phy_test_pattern_request( 906 struct dp_link_private *link) 907 { 908 if (!(link->request.test_requested & DP_TEST_LINK_PHY_TEST_PATTERN)) { 909 drm_dbg_dp(link->drm_dev, "no phy test\n"); 910 return -EINVAL; 911 } 912 913 if (!is_link_rate_valid(link->request.test_link_rate) || 914 !is_lane_count_valid(link->request.test_lane_count)) { 915 DRM_ERROR("Invalid: link rate = 0x%x,lane count = 0x%x\n", 916 link->request.test_link_rate, 917 link->request.test_lane_count); 918 return -EINVAL; 919 } 920 921 drm_dbg_dp(link->drm_dev, 922 "Current: rate = 0x%x, lane count = 0x%x\n", 923 link->dp_link.link_params.rate, 924 link->dp_link.link_params.num_lanes); 925 926 drm_dbg_dp(link->drm_dev, 927 "Requested: rate = 0x%x, lane count = 0x%x\n", 928 link->request.test_link_rate, 929 link->request.test_lane_count); 930 931 link->dp_link.link_params.num_lanes = link->request.test_lane_count; 932 link->dp_link.link_params.rate = 933 drm_dp_bw_code_to_link_rate(link->request.test_link_rate); 934 935 dp_link_parse_vx_px(link); 936 937 return 0; 938 } 939 940 static bool dp_link_read_psr_error_status(struct dp_link_private *link) 941 { 942 u8 status; 943 944 drm_dp_dpcd_read(link->aux, DP_PSR_ERROR_STATUS, &status, 1); 945 946 if (status & DP_PSR_LINK_CRC_ERROR) 947 DRM_ERROR("PSR LINK CRC ERROR\n"); 948 else if (status & DP_PSR_RFB_STORAGE_ERROR) 949 DRM_ERROR("PSR RFB STORAGE ERROR\n"); 950 else if (status & DP_PSR_VSC_SDP_UNCORRECTABLE_ERROR) 951 DRM_ERROR("PSR VSC SDP UNCORRECTABLE ERROR\n"); 952 else 953 return false; 954 955 return true; 956 } 957 958 static bool dp_link_psr_capability_changed(struct dp_link_private *link) 959 { 960 u8 status; 961 962 drm_dp_dpcd_read(link->aux, DP_PSR_ESI, &status, 1); 963 964 if (status & DP_PSR_CAPS_CHANGE) { 965 drm_dbg_dp(link->drm_dev, "PSR Capability Change\n"); 966 return true; 967 } 968 969 return false; 970 } 971 972 static u8 get_link_status(const u8 link_status[DP_LINK_STATUS_SIZE], int r) 973 { 974 return link_status[r - DP_LANE0_1_STATUS]; 975 } 976 977 /** 978 * dp_link_process_link_status_update() - processes link status updates 979 * @link: Display Port link module data 980 * 981 * This function will check for changes in the link status, e.g. clock 982 * recovery done on all lanes, and trigger link training if there is a 983 * failure/error on the link. 984 * 985 * The function will return 0 if the a link status update has been processed, 986 * otherwise it will return -EINVAL. 987 */ 988 static int dp_link_process_link_status_update(struct dp_link_private *link) 989 { 990 bool channel_eq_done = drm_dp_channel_eq_ok(link->link_status, 991 link->dp_link.link_params.num_lanes); 992 993 bool clock_recovery_done = drm_dp_clock_recovery_ok(link->link_status, 994 link->dp_link.link_params.num_lanes); 995 996 drm_dbg_dp(link->drm_dev, 997 "channel_eq_done = %d, clock_recovery_done = %d\n", 998 channel_eq_done, clock_recovery_done); 999 1000 if (channel_eq_done && clock_recovery_done) 1001 return -EINVAL; 1002 1003 return 0; 1004 } 1005 1006 /** 1007 * dp_link_process_ds_port_status_change() - process port status changes 1008 * @link: Display Port Driver data 1009 * 1010 * This function will handle downstream port updates that are initiated by 1011 * the sink. If the downstream port status has changed, the EDID is read via 1012 * AUX. 1013 * 1014 * The function will return 0 if a downstream port update has been 1015 * processed, otherwise it will return -EINVAL. 1016 */ 1017 static int dp_link_process_ds_port_status_change(struct dp_link_private *link) 1018 { 1019 if (get_link_status(link->link_status, DP_LANE_ALIGN_STATUS_UPDATED) & 1020 DP_DOWNSTREAM_PORT_STATUS_CHANGED) 1021 goto reset; 1022 1023 if (link->prev_sink_count == link->dp_link.sink_count) 1024 return -EINVAL; 1025 1026 reset: 1027 /* reset prev_sink_count */ 1028 link->prev_sink_count = link->dp_link.sink_count; 1029 1030 return 0; 1031 } 1032 1033 static bool dp_link_is_video_pattern_requested(struct dp_link_private *link) 1034 { 1035 return (link->request.test_requested & DP_TEST_LINK_VIDEO_PATTERN) 1036 && !(link->request.test_requested & 1037 DP_TEST_LINK_AUDIO_DISABLED_VIDEO); 1038 } 1039 1040 static bool dp_link_is_audio_pattern_requested(struct dp_link_private *link) 1041 { 1042 return (link->request.test_requested & DP_TEST_LINK_AUDIO_PATTERN); 1043 } 1044 1045 static void dp_link_reset_data(struct dp_link_private *link) 1046 { 1047 link->request = (const struct dp_link_request){ 0 }; 1048 link->dp_link.test_video = (const struct dp_link_test_video){ 0 }; 1049 link->dp_link.test_video.test_bit_depth = DP_TEST_BIT_DEPTH_UNKNOWN; 1050 link->dp_link.test_audio = (const struct dp_link_test_audio){ 0 }; 1051 link->dp_link.phy_params.phy_test_pattern_sel = 0; 1052 link->dp_link.sink_request = 0; 1053 link->dp_link.test_response = 0; 1054 } 1055 1056 /** 1057 * dp_link_process_request() - handle HPD IRQ transition to HIGH 1058 * @dp_link: pointer to link module data 1059 * 1060 * This function will handle the HPD IRQ state transitions from LOW to HIGH 1061 * (including cases when there are back to back HPD IRQ HIGH) indicating 1062 * the start of a new link training request or sink status update. 1063 */ 1064 int dp_link_process_request(struct dp_link *dp_link) 1065 { 1066 int ret = 0; 1067 struct dp_link_private *link; 1068 1069 if (!dp_link) { 1070 DRM_ERROR("invalid input\n"); 1071 return -EINVAL; 1072 } 1073 1074 link = container_of(dp_link, struct dp_link_private, dp_link); 1075 1076 dp_link_reset_data(link); 1077 1078 ret = dp_link_parse_sink_status_field(link); 1079 if (ret) 1080 return ret; 1081 1082 if (link->request.test_requested == DP_TEST_LINK_EDID_READ) { 1083 dp_link->sink_request |= DP_TEST_LINK_EDID_READ; 1084 } else if (!dp_link_process_ds_port_status_change(link)) { 1085 dp_link->sink_request |= DS_PORT_STATUS_CHANGED; 1086 } else if (!dp_link_process_link_training_request(link)) { 1087 dp_link->sink_request |= DP_TEST_LINK_TRAINING; 1088 } else if (!dp_link_process_phy_test_pattern_request(link)) { 1089 dp_link->sink_request |= DP_TEST_LINK_PHY_TEST_PATTERN; 1090 } else if (dp_link_read_psr_error_status(link)) { 1091 DRM_ERROR("PSR IRQ_HPD received\n"); 1092 } else if (dp_link_psr_capability_changed(link)) { 1093 drm_dbg_dp(link->drm_dev, "PSR Capability changed\n"); 1094 } else { 1095 ret = dp_link_process_link_status_update(link); 1096 if (!ret) { 1097 dp_link->sink_request |= DP_LINK_STATUS_UPDATED; 1098 } else { 1099 if (dp_link_is_video_pattern_requested(link)) { 1100 ret = 0; 1101 dp_link->sink_request |= DP_TEST_LINK_VIDEO_PATTERN; 1102 } 1103 if (dp_link_is_audio_pattern_requested(link)) { 1104 dp_link->sink_request |= DP_TEST_LINK_AUDIO_PATTERN; 1105 ret = -EINVAL; 1106 } 1107 } 1108 } 1109 1110 drm_dbg_dp(link->drm_dev, "sink request=%#x\n", 1111 dp_link->sink_request); 1112 return ret; 1113 } 1114 1115 int dp_link_get_colorimetry_config(struct dp_link *dp_link) 1116 { 1117 u32 cc; 1118 struct dp_link_private *link; 1119 1120 if (!dp_link) { 1121 DRM_ERROR("invalid input\n"); 1122 return -EINVAL; 1123 } 1124 1125 link = container_of(dp_link, struct dp_link_private, dp_link); 1126 1127 /* 1128 * Unless a video pattern CTS test is ongoing, use RGB_VESA 1129 * Only RGB_VESA and RGB_CEA supported for now 1130 */ 1131 if (dp_link_is_video_pattern_requested(link)) 1132 cc = link->dp_link.test_video.test_dyn_range; 1133 else 1134 cc = DP_TEST_DYNAMIC_RANGE_VESA; 1135 1136 return cc; 1137 } 1138 1139 int dp_link_adjust_levels(struct dp_link *dp_link, u8 *link_status) 1140 { 1141 int i; 1142 int v_max = 0, p_max = 0; 1143 struct dp_link_private *link; 1144 1145 if (!dp_link) { 1146 DRM_ERROR("invalid input\n"); 1147 return -EINVAL; 1148 } 1149 1150 link = container_of(dp_link, struct dp_link_private, dp_link); 1151 1152 /* use the max level across lanes */ 1153 for (i = 0; i < dp_link->link_params.num_lanes; i++) { 1154 u8 data_v = drm_dp_get_adjust_request_voltage(link_status, i); 1155 u8 data_p = drm_dp_get_adjust_request_pre_emphasis(link_status, 1156 i); 1157 drm_dbg_dp(link->drm_dev, 1158 "lane=%d req_vol_swing=%d req_pre_emphasis=%d\n", 1159 i, data_v, data_p); 1160 if (v_max < data_v) 1161 v_max = data_v; 1162 if (p_max < data_p) 1163 p_max = data_p; 1164 } 1165 1166 dp_link->phy_params.v_level = v_max >> DP_TRAIN_VOLTAGE_SWING_SHIFT; 1167 dp_link->phy_params.p_level = p_max >> DP_TRAIN_PRE_EMPHASIS_SHIFT; 1168 1169 /** 1170 * Adjust the voltage swing and pre-emphasis level combination to within 1171 * the allowable range. 1172 */ 1173 if (dp_link->phy_params.v_level > DP_TRAIN_VOLTAGE_SWING_MAX) { 1174 drm_dbg_dp(link->drm_dev, 1175 "Requested vSwingLevel=%d, change to %d\n", 1176 dp_link->phy_params.v_level, 1177 DP_TRAIN_VOLTAGE_SWING_MAX); 1178 dp_link->phy_params.v_level = DP_TRAIN_VOLTAGE_SWING_MAX; 1179 } 1180 1181 if (dp_link->phy_params.p_level > DP_TRAIN_PRE_EMPHASIS_MAX) { 1182 drm_dbg_dp(link->drm_dev, 1183 "Requested preEmphasisLevel=%d, change to %d\n", 1184 dp_link->phy_params.p_level, 1185 DP_TRAIN_PRE_EMPHASIS_MAX); 1186 dp_link->phy_params.p_level = DP_TRAIN_PRE_EMPHASIS_MAX; 1187 } 1188 1189 if ((dp_link->phy_params.p_level > DP_TRAIN_PRE_EMPHASIS_LVL_1) 1190 && (dp_link->phy_params.v_level == 1191 DP_TRAIN_VOLTAGE_SWING_LVL_2)) { 1192 drm_dbg_dp(link->drm_dev, 1193 "Requested preEmphasisLevel=%d, change to %d\n", 1194 dp_link->phy_params.p_level, 1195 DP_TRAIN_PRE_EMPHASIS_LVL_1); 1196 dp_link->phy_params.p_level = DP_TRAIN_PRE_EMPHASIS_LVL_1; 1197 } 1198 1199 drm_dbg_dp(link->drm_dev, "adjusted: v_level=%d, p_level=%d\n", 1200 dp_link->phy_params.v_level, dp_link->phy_params.p_level); 1201 1202 return 0; 1203 } 1204 1205 void dp_link_reset_phy_params_vx_px(struct dp_link *dp_link) 1206 { 1207 dp_link->phy_params.v_level = 0; 1208 dp_link->phy_params.p_level = 0; 1209 } 1210 1211 u32 dp_link_get_test_bits_depth(struct dp_link *dp_link, u32 bpp) 1212 { 1213 u32 tbd; 1214 1215 /* 1216 * Few simplistic rules and assumptions made here: 1217 * 1. Test bit depth is bit depth per color component 1218 * 2. Assume 3 color components 1219 */ 1220 switch (bpp) { 1221 case 18: 1222 tbd = DP_TEST_BIT_DEPTH_6; 1223 break; 1224 case 24: 1225 tbd = DP_TEST_BIT_DEPTH_8; 1226 break; 1227 case 30: 1228 tbd = DP_TEST_BIT_DEPTH_10; 1229 break; 1230 default: 1231 tbd = DP_TEST_BIT_DEPTH_UNKNOWN; 1232 break; 1233 } 1234 1235 if (tbd != DP_TEST_BIT_DEPTH_UNKNOWN) 1236 tbd = (tbd >> DP_TEST_BIT_DEPTH_SHIFT); 1237 1238 return tbd; 1239 } 1240 1241 struct dp_link *dp_link_get(struct device *dev, struct drm_dp_aux *aux) 1242 { 1243 struct dp_link_private *link; 1244 struct dp_link *dp_link; 1245 1246 if (!dev || !aux) { 1247 DRM_ERROR("invalid input\n"); 1248 return ERR_PTR(-EINVAL); 1249 } 1250 1251 link = devm_kzalloc(dev, sizeof(*link), GFP_KERNEL); 1252 if (!link) 1253 return ERR_PTR(-ENOMEM); 1254 1255 link->dev = dev; 1256 link->aux = aux; 1257 1258 mutex_init(&link->psm_mutex); 1259 dp_link = &link->dp_link; 1260 1261 return dp_link; 1262 } 1263