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 = link->request.test_link_rate; 777 778 return 0; 779 } 780 781 bool dp_link_send_test_response(struct dp_link *dp_link) 782 { 783 struct dp_link_private *link = NULL; 784 int ret = 0; 785 786 if (!dp_link) { 787 DRM_ERROR("invalid input\n"); 788 return false; 789 } 790 791 link = container_of(dp_link, struct dp_link_private, dp_link); 792 793 ret = drm_dp_dpcd_writeb(link->aux, DP_TEST_RESPONSE, 794 dp_link->test_response); 795 796 return ret == 1; 797 } 798 799 int dp_link_psm_config(struct dp_link *dp_link, 800 struct dp_link_info *link_info, bool enable) 801 { 802 struct dp_link_private *link = NULL; 803 int ret = 0; 804 805 if (!dp_link) { 806 DRM_ERROR("invalid params\n"); 807 return -EINVAL; 808 } 809 810 link = container_of(dp_link, struct dp_link_private, dp_link); 811 812 mutex_lock(&link->psm_mutex); 813 if (enable) 814 ret = dp_aux_link_power_down(link->aux, link_info); 815 else 816 ret = dp_aux_link_power_up(link->aux, link_info); 817 818 if (ret) 819 DRM_ERROR("Failed to %s low power mode\n", enable ? 820 "enter" : "exit"); 821 else 822 dp_link->psm_enabled = enable; 823 824 mutex_unlock(&link->psm_mutex); 825 return ret; 826 } 827 828 bool dp_link_send_edid_checksum(struct dp_link *dp_link, u8 checksum) 829 { 830 struct dp_link_private *link = NULL; 831 int ret = 0; 832 833 if (!dp_link) { 834 DRM_ERROR("invalid input\n"); 835 return false; 836 } 837 838 link = container_of(dp_link, struct dp_link_private, dp_link); 839 840 ret = drm_dp_dpcd_writeb(link->aux, DP_TEST_EDID_CHECKSUM, 841 checksum); 842 return ret == 1; 843 } 844 845 static int dp_link_parse_vx_px(struct dp_link_private *link) 846 { 847 int ret = 0; 848 849 DRM_DEBUG_DP("vx: 0=%d, 1=%d, 2=%d, 3=%d\n", 850 drm_dp_get_adjust_request_voltage(link->link_status, 0), 851 drm_dp_get_adjust_request_voltage(link->link_status, 1), 852 drm_dp_get_adjust_request_voltage(link->link_status, 2), 853 drm_dp_get_adjust_request_voltage(link->link_status, 3)); 854 855 DRM_DEBUG_DP("px: 0=%d, 1=%d, 2=%d, 3=%d\n", 856 drm_dp_get_adjust_request_pre_emphasis(link->link_status, 0), 857 drm_dp_get_adjust_request_pre_emphasis(link->link_status, 1), 858 drm_dp_get_adjust_request_pre_emphasis(link->link_status, 2), 859 drm_dp_get_adjust_request_pre_emphasis(link->link_status, 3)); 860 861 /** 862 * Update the voltage and pre-emphasis levels as per DPCD request 863 * vector. 864 */ 865 DRM_DEBUG_DP("Current: v_level = 0x%x, p_level = 0x%x\n", 866 link->dp_link.phy_params.v_level, 867 link->dp_link.phy_params.p_level); 868 link->dp_link.phy_params.v_level = 869 drm_dp_get_adjust_request_voltage(link->link_status, 0); 870 link->dp_link.phy_params.p_level = 871 drm_dp_get_adjust_request_pre_emphasis(link->link_status, 0); 872 DRM_DEBUG_DP("Requested: v_level = 0x%x, p_level = 0x%x\n", 873 link->dp_link.phy_params.v_level, 874 link->dp_link.phy_params.p_level); 875 876 return ret; 877 } 878 879 /** 880 * dp_link_process_phy_test_pattern_request() - process new phy link requests 881 * @link: Display Port Driver data 882 * 883 * This function will handle new phy link pattern requests that are initiated 884 * by the sink. The function will return 0 if a phy link pattern has been 885 * processed, otherwise it will return -EINVAL. 886 */ 887 static int dp_link_process_phy_test_pattern_request( 888 struct dp_link_private *link) 889 { 890 int ret = 0; 891 892 if (!(link->request.test_requested & DP_TEST_LINK_PHY_TEST_PATTERN)) { 893 DRM_DEBUG_DP("no phy test\n"); 894 return -EINVAL; 895 } 896 897 if (!is_link_rate_valid(link->request.test_link_rate) || 898 !is_lane_count_valid(link->request.test_lane_count)) { 899 DRM_ERROR("Invalid: link rate = 0x%x,lane count = 0x%x\n", 900 link->request.test_link_rate, 901 link->request.test_lane_count); 902 return -EINVAL; 903 } 904 905 DRM_DEBUG_DP("Current: rate = 0x%x, lane count = 0x%x\n", 906 link->dp_link.link_params.rate, 907 link->dp_link.link_params.num_lanes); 908 909 DRM_DEBUG_DP("Requested: rate = 0x%x, lane count = 0x%x\n", 910 link->request.test_link_rate, 911 link->request.test_lane_count); 912 913 link->dp_link.link_params.num_lanes = link->request.test_lane_count; 914 link->dp_link.link_params.rate = link->request.test_link_rate; 915 916 ret = dp_link_parse_vx_px(link); 917 918 if (ret) 919 DRM_ERROR("parse_vx_px failed. ret=%d\n", ret); 920 921 return ret; 922 } 923 924 static u8 get_link_status(const u8 link_status[DP_LINK_STATUS_SIZE], int r) 925 { 926 return link_status[r - DP_LANE0_1_STATUS]; 927 } 928 929 /** 930 * dp_link_process_link_status_update() - processes link status updates 931 * @link: Display Port link module data 932 * 933 * This function will check for changes in the link status, e.g. clock 934 * recovery done on all lanes, and trigger link training if there is a 935 * failure/error on the link. 936 * 937 * The function will return 0 if the a link status update has been processed, 938 * otherwise it will return -EINVAL. 939 */ 940 static int dp_link_process_link_status_update(struct dp_link_private *link) 941 { 942 if (!(get_link_status(link->link_status, 943 DP_LANE_ALIGN_STATUS_UPDATED) & 944 DP_LINK_STATUS_UPDATED) || 945 (drm_dp_clock_recovery_ok(link->link_status, 946 link->dp_link.link_params.num_lanes) && 947 drm_dp_channel_eq_ok(link->link_status, 948 link->dp_link.link_params.num_lanes))) 949 return -EINVAL; 950 951 DRM_DEBUG_DP("channel_eq_done = %d, clock_recovery_done = %d\n", 952 drm_dp_clock_recovery_ok(link->link_status, 953 link->dp_link.link_params.num_lanes), 954 drm_dp_clock_recovery_ok(link->link_status, 955 link->dp_link.link_params.num_lanes)); 956 957 return 0; 958 } 959 960 /** 961 * dp_link_process_downstream_port_status_change() - process port status changes 962 * @link: Display Port Driver data 963 * 964 * This function will handle downstream port updates that are initiated by 965 * the sink. If the downstream port status has changed, the EDID is read via 966 * AUX. 967 * 968 * The function will return 0 if a downstream port update has been 969 * processed, otherwise it will return -EINVAL. 970 */ 971 static int dp_link_process_ds_port_status_change(struct dp_link_private *link) 972 { 973 if (get_link_status(link->link_status, DP_LANE_ALIGN_STATUS_UPDATED) & 974 DP_DOWNSTREAM_PORT_STATUS_CHANGED) 975 goto reset; 976 977 if (link->prev_sink_count == link->dp_link.sink_count) 978 return -EINVAL; 979 980 reset: 981 /* reset prev_sink_count */ 982 link->prev_sink_count = link->dp_link.sink_count; 983 984 return 0; 985 } 986 987 static bool dp_link_is_video_pattern_requested(struct dp_link_private *link) 988 { 989 return (link->request.test_requested & DP_TEST_LINK_VIDEO_PATTERN) 990 && !(link->request.test_requested & 991 DP_TEST_LINK_AUDIO_DISABLED_VIDEO); 992 } 993 994 static bool dp_link_is_audio_pattern_requested(struct dp_link_private *link) 995 { 996 return (link->request.test_requested & DP_TEST_LINK_AUDIO_PATTERN); 997 } 998 999 static void dp_link_reset_data(struct dp_link_private *link) 1000 { 1001 link->request = (const struct dp_link_request){ 0 }; 1002 link->dp_link.test_video = (const struct dp_link_test_video){ 0 }; 1003 link->dp_link.test_video.test_bit_depth = DP_TEST_BIT_DEPTH_UNKNOWN; 1004 link->dp_link.test_audio = (const struct dp_link_test_audio){ 0 }; 1005 link->dp_link.phy_params.phy_test_pattern_sel = 0; 1006 link->dp_link.sink_request = 0; 1007 link->dp_link.test_response = 0; 1008 } 1009 1010 /** 1011 * dp_link_process_request() - handle HPD IRQ transition to HIGH 1012 * @dp_link: pointer to link module data 1013 * 1014 * This function will handle the HPD IRQ state transitions from LOW to HIGH 1015 * (including cases when there are back to back HPD IRQ HIGH) indicating 1016 * the start of a new link training request or sink status update. 1017 */ 1018 int dp_link_process_request(struct dp_link *dp_link) 1019 { 1020 int ret = 0; 1021 struct dp_link_private *link; 1022 1023 if (!dp_link) { 1024 DRM_ERROR("invalid input\n"); 1025 return -EINVAL; 1026 } 1027 1028 link = container_of(dp_link, struct dp_link_private, dp_link); 1029 1030 dp_link_reset_data(link); 1031 1032 dp_link_parse_sink_status_field(link); 1033 1034 if (link->request.test_requested == DP_TEST_LINK_EDID_READ) { 1035 dp_link->sink_request |= DP_TEST_LINK_EDID_READ; 1036 return ret; 1037 } 1038 1039 ret = dp_link_process_ds_port_status_change(link); 1040 if (!ret) { 1041 dp_link->sink_request |= DS_PORT_STATUS_CHANGED; 1042 return ret; 1043 } 1044 1045 ret = dp_link_process_link_training_request(link); 1046 if (!ret) { 1047 dp_link->sink_request |= DP_TEST_LINK_TRAINING; 1048 return ret; 1049 } 1050 1051 ret = dp_link_process_phy_test_pattern_request(link); 1052 if (!ret) { 1053 dp_link->sink_request |= DP_TEST_LINK_PHY_TEST_PATTERN; 1054 return ret; 1055 } 1056 1057 ret = dp_link_process_link_status_update(link); 1058 if (!ret) { 1059 dp_link->sink_request |= DP_LINK_STATUS_UPDATED; 1060 return ret; 1061 } 1062 1063 if (dp_link_is_video_pattern_requested(link)) { 1064 ret = 0; 1065 dp_link->sink_request |= DP_TEST_LINK_VIDEO_PATTERN; 1066 } 1067 1068 if (dp_link_is_audio_pattern_requested(link)) { 1069 dp_link->sink_request |= DP_TEST_LINK_AUDIO_PATTERN; 1070 return -EINVAL; 1071 } 1072 1073 return ret; 1074 } 1075 1076 int dp_link_get_colorimetry_config(struct dp_link *dp_link) 1077 { 1078 u32 cc; 1079 struct dp_link_private *link; 1080 1081 if (!dp_link) { 1082 DRM_ERROR("invalid input\n"); 1083 return -EINVAL; 1084 } 1085 1086 link = container_of(dp_link, struct dp_link_private, dp_link); 1087 1088 /* 1089 * Unless a video pattern CTS test is ongoing, use RGB_VESA 1090 * Only RGB_VESA and RGB_CEA supported for now 1091 */ 1092 if (dp_link_is_video_pattern_requested(link)) 1093 cc = link->dp_link.test_video.test_dyn_range; 1094 else 1095 cc = DP_TEST_DYNAMIC_RANGE_VESA; 1096 1097 return cc; 1098 } 1099 1100 int dp_link_adjust_levels(struct dp_link *dp_link, u8 *link_status) 1101 { 1102 int i; 1103 int v_max = 0, p_max = 0; 1104 1105 if (!dp_link) { 1106 DRM_ERROR("invalid input\n"); 1107 return -EINVAL; 1108 } 1109 1110 /* use the max level across lanes */ 1111 for (i = 0; i < dp_link->link_params.num_lanes; i++) { 1112 u8 data_v = drm_dp_get_adjust_request_voltage(link_status, i); 1113 u8 data_p = drm_dp_get_adjust_request_pre_emphasis(link_status, 1114 i); 1115 DRM_DEBUG_DP("lane=%d req_vol_swing=%d req_pre_emphasis=%d\n", 1116 i, data_v, data_p); 1117 if (v_max < data_v) 1118 v_max = data_v; 1119 if (p_max < data_p) 1120 p_max = data_p; 1121 } 1122 1123 dp_link->phy_params.v_level = v_max >> DP_TRAIN_VOLTAGE_SWING_SHIFT; 1124 dp_link->phy_params.p_level = p_max >> DP_TRAIN_PRE_EMPHASIS_SHIFT; 1125 1126 /** 1127 * Adjust the voltage swing and pre-emphasis level combination to within 1128 * the allowable range. 1129 */ 1130 if (dp_link->phy_params.v_level > DP_TRAIN_VOLTAGE_SWING_MAX) { 1131 DRM_DEBUG_DP("Requested vSwingLevel=%d, change to %d\n", 1132 dp_link->phy_params.v_level, 1133 DP_TRAIN_VOLTAGE_SWING_MAX); 1134 dp_link->phy_params.v_level = DP_TRAIN_VOLTAGE_SWING_MAX; 1135 } 1136 1137 if (dp_link->phy_params.p_level > DP_TRAIN_PRE_EMPHASIS_MAX) { 1138 DRM_DEBUG_DP("Requested preEmphasisLevel=%d, change to %d\n", 1139 dp_link->phy_params.p_level, 1140 DP_TRAIN_PRE_EMPHASIS_MAX); 1141 dp_link->phy_params.p_level = DP_TRAIN_PRE_EMPHASIS_MAX; 1142 } 1143 1144 if ((dp_link->phy_params.p_level > DP_TRAIN_PRE_EMPHASIS_LVL_1) 1145 && (dp_link->phy_params.v_level == 1146 DP_TRAIN_VOLTAGE_SWING_LVL_2)) { 1147 DRM_DEBUG_DP("Requested preEmphasisLevel=%d, change to %d\n", 1148 dp_link->phy_params.p_level, 1149 DP_TRAIN_PRE_EMPHASIS_LVL_1); 1150 dp_link->phy_params.p_level = DP_TRAIN_PRE_EMPHASIS_LVL_1; 1151 } 1152 1153 DRM_DEBUG_DP("adjusted: v_level=%d, p_level=%d\n", 1154 dp_link->phy_params.v_level, dp_link->phy_params.p_level); 1155 1156 return 0; 1157 } 1158 1159 u32 dp_link_get_test_bits_depth(struct dp_link *dp_link, u32 bpp) 1160 { 1161 u32 tbd; 1162 1163 /* 1164 * Few simplistic rules and assumptions made here: 1165 * 1. Test bit depth is bit depth per color component 1166 * 2. Assume 3 color components 1167 */ 1168 switch (bpp) { 1169 case 18: 1170 tbd = DP_TEST_BIT_DEPTH_6; 1171 break; 1172 case 24: 1173 tbd = DP_TEST_BIT_DEPTH_8; 1174 break; 1175 case 30: 1176 tbd = DP_TEST_BIT_DEPTH_10; 1177 break; 1178 default: 1179 tbd = DP_TEST_BIT_DEPTH_UNKNOWN; 1180 break; 1181 } 1182 1183 if (tbd != DP_TEST_BIT_DEPTH_UNKNOWN) 1184 tbd = (tbd >> DP_TEST_BIT_DEPTH_SHIFT); 1185 1186 return tbd; 1187 } 1188 1189 struct dp_link *dp_link_get(struct device *dev, struct drm_dp_aux *aux) 1190 { 1191 struct dp_link_private *link; 1192 struct dp_link *dp_link; 1193 1194 if (!dev || !aux) { 1195 DRM_ERROR("invalid input\n"); 1196 return ERR_PTR(-EINVAL); 1197 } 1198 1199 link = devm_kzalloc(dev, sizeof(*link), GFP_KERNEL); 1200 if (!link) 1201 return ERR_PTR(-ENOMEM); 1202 1203 link->dev = dev; 1204 link->aux = aux; 1205 1206 mutex_init(&link->psm_mutex); 1207 dp_link = &link->dp_link; 1208 1209 return dp_link; 1210 } 1211