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