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 u8 get_link_status(const u8 link_status[DP_LINK_STATUS_SIZE], int r) 941 { 942 return link_status[r - DP_LANE0_1_STATUS]; 943 } 944 945 /** 946 * dp_link_process_link_status_update() - processes link status updates 947 * @link: Display Port link module data 948 * 949 * This function will check for changes in the link status, e.g. clock 950 * recovery done on all lanes, and trigger link training if there is a 951 * failure/error on the link. 952 * 953 * The function will return 0 if the a link status update has been processed, 954 * otherwise it will return -EINVAL. 955 */ 956 static int dp_link_process_link_status_update(struct dp_link_private *link) 957 { 958 bool channel_eq_done = drm_dp_channel_eq_ok(link->link_status, 959 link->dp_link.link_params.num_lanes); 960 961 bool clock_recovery_done = drm_dp_clock_recovery_ok(link->link_status, 962 link->dp_link.link_params.num_lanes); 963 964 drm_dbg_dp(link->drm_dev, 965 "channel_eq_done = %d, clock_recovery_done = %d\n", 966 channel_eq_done, clock_recovery_done); 967 968 if (channel_eq_done && clock_recovery_done) 969 return -EINVAL; 970 971 return 0; 972 } 973 974 /** 975 * dp_link_process_ds_port_status_change() - process port status changes 976 * @link: Display Port Driver data 977 * 978 * This function will handle downstream port updates that are initiated by 979 * the sink. If the downstream port status has changed, the EDID is read via 980 * AUX. 981 * 982 * The function will return 0 if a downstream port update has been 983 * processed, otherwise it will return -EINVAL. 984 */ 985 static int dp_link_process_ds_port_status_change(struct dp_link_private *link) 986 { 987 if (get_link_status(link->link_status, DP_LANE_ALIGN_STATUS_UPDATED) & 988 DP_DOWNSTREAM_PORT_STATUS_CHANGED) 989 goto reset; 990 991 if (link->prev_sink_count == link->dp_link.sink_count) 992 return -EINVAL; 993 994 reset: 995 /* reset prev_sink_count */ 996 link->prev_sink_count = link->dp_link.sink_count; 997 998 return 0; 999 } 1000 1001 static bool dp_link_is_video_pattern_requested(struct dp_link_private *link) 1002 { 1003 return (link->request.test_requested & DP_TEST_LINK_VIDEO_PATTERN) 1004 && !(link->request.test_requested & 1005 DP_TEST_LINK_AUDIO_DISABLED_VIDEO); 1006 } 1007 1008 static bool dp_link_is_audio_pattern_requested(struct dp_link_private *link) 1009 { 1010 return (link->request.test_requested & DP_TEST_LINK_AUDIO_PATTERN); 1011 } 1012 1013 static void dp_link_reset_data(struct dp_link_private *link) 1014 { 1015 link->request = (const struct dp_link_request){ 0 }; 1016 link->dp_link.test_video = (const struct dp_link_test_video){ 0 }; 1017 link->dp_link.test_video.test_bit_depth = DP_TEST_BIT_DEPTH_UNKNOWN; 1018 link->dp_link.test_audio = (const struct dp_link_test_audio){ 0 }; 1019 link->dp_link.phy_params.phy_test_pattern_sel = 0; 1020 link->dp_link.sink_request = 0; 1021 link->dp_link.test_response = 0; 1022 } 1023 1024 /** 1025 * dp_link_process_request() - handle HPD IRQ transition to HIGH 1026 * @dp_link: pointer to link module data 1027 * 1028 * This function will handle the HPD IRQ state transitions from LOW to HIGH 1029 * (including cases when there are back to back HPD IRQ HIGH) indicating 1030 * the start of a new link training request or sink status update. 1031 */ 1032 int dp_link_process_request(struct dp_link *dp_link) 1033 { 1034 int ret = 0; 1035 struct dp_link_private *link; 1036 1037 if (!dp_link) { 1038 DRM_ERROR("invalid input\n"); 1039 return -EINVAL; 1040 } 1041 1042 link = container_of(dp_link, struct dp_link_private, dp_link); 1043 1044 dp_link_reset_data(link); 1045 1046 ret = dp_link_parse_sink_status_field(link); 1047 if (ret) 1048 return ret; 1049 1050 if (link->request.test_requested == DP_TEST_LINK_EDID_READ) { 1051 dp_link->sink_request |= DP_TEST_LINK_EDID_READ; 1052 } else if (!dp_link_process_ds_port_status_change(link)) { 1053 dp_link->sink_request |= DS_PORT_STATUS_CHANGED; 1054 } else if (!dp_link_process_link_training_request(link)) { 1055 dp_link->sink_request |= DP_TEST_LINK_TRAINING; 1056 } else if (!dp_link_process_phy_test_pattern_request(link)) { 1057 dp_link->sink_request |= DP_TEST_LINK_PHY_TEST_PATTERN; 1058 } else { 1059 ret = dp_link_process_link_status_update(link); 1060 if (!ret) { 1061 dp_link->sink_request |= DP_LINK_STATUS_UPDATED; 1062 } else { 1063 if (dp_link_is_video_pattern_requested(link)) { 1064 ret = 0; 1065 dp_link->sink_request |= DP_TEST_LINK_VIDEO_PATTERN; 1066 } 1067 if (dp_link_is_audio_pattern_requested(link)) { 1068 dp_link->sink_request |= DP_TEST_LINK_AUDIO_PATTERN; 1069 ret = -EINVAL; 1070 } 1071 } 1072 } 1073 1074 drm_dbg_dp(link->drm_dev, "sink request=%#x", 1075 dp_link->sink_request); 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 struct dp_link_private *link; 1108 1109 if (!dp_link) { 1110 DRM_ERROR("invalid input\n"); 1111 return -EINVAL; 1112 } 1113 1114 link = container_of(dp_link, struct dp_link_private, dp_link); 1115 1116 /* use the max level across lanes */ 1117 for (i = 0; i < dp_link->link_params.num_lanes; i++) { 1118 u8 data_v = drm_dp_get_adjust_request_voltage(link_status, i); 1119 u8 data_p = drm_dp_get_adjust_request_pre_emphasis(link_status, 1120 i); 1121 drm_dbg_dp(link->drm_dev, 1122 "lane=%d req_vol_swing=%d req_pre_emphasis=%d\n", 1123 i, data_v, data_p); 1124 if (v_max < data_v) 1125 v_max = data_v; 1126 if (p_max < data_p) 1127 p_max = data_p; 1128 } 1129 1130 dp_link->phy_params.v_level = v_max >> DP_TRAIN_VOLTAGE_SWING_SHIFT; 1131 dp_link->phy_params.p_level = p_max >> DP_TRAIN_PRE_EMPHASIS_SHIFT; 1132 1133 /** 1134 * Adjust the voltage swing and pre-emphasis level combination to within 1135 * the allowable range. 1136 */ 1137 if (dp_link->phy_params.v_level > DP_TRAIN_VOLTAGE_SWING_MAX) { 1138 drm_dbg_dp(link->drm_dev, 1139 "Requested vSwingLevel=%d, change to %d\n", 1140 dp_link->phy_params.v_level, 1141 DP_TRAIN_VOLTAGE_SWING_MAX); 1142 dp_link->phy_params.v_level = DP_TRAIN_VOLTAGE_SWING_MAX; 1143 } 1144 1145 if (dp_link->phy_params.p_level > DP_TRAIN_PRE_EMPHASIS_MAX) { 1146 drm_dbg_dp(link->drm_dev, 1147 "Requested preEmphasisLevel=%d, change to %d\n", 1148 dp_link->phy_params.p_level, 1149 DP_TRAIN_PRE_EMPHASIS_MAX); 1150 dp_link->phy_params.p_level = DP_TRAIN_PRE_EMPHASIS_MAX; 1151 } 1152 1153 if ((dp_link->phy_params.p_level > DP_TRAIN_PRE_EMPHASIS_LVL_1) 1154 && (dp_link->phy_params.v_level == 1155 DP_TRAIN_VOLTAGE_SWING_LVL_2)) { 1156 drm_dbg_dp(link->drm_dev, 1157 "Requested preEmphasisLevel=%d, change to %d\n", 1158 dp_link->phy_params.p_level, 1159 DP_TRAIN_PRE_EMPHASIS_LVL_1); 1160 dp_link->phy_params.p_level = DP_TRAIN_PRE_EMPHASIS_LVL_1; 1161 } 1162 1163 drm_dbg_dp(link->drm_dev, "adjusted: v_level=%d, p_level=%d\n", 1164 dp_link->phy_params.v_level, dp_link->phy_params.p_level); 1165 1166 return 0; 1167 } 1168 1169 void dp_link_reset_phy_params_vx_px(struct dp_link *dp_link) 1170 { 1171 dp_link->phy_params.v_level = 0; 1172 dp_link->phy_params.p_level = 0; 1173 } 1174 1175 u32 dp_link_get_test_bits_depth(struct dp_link *dp_link, u32 bpp) 1176 { 1177 u32 tbd; 1178 1179 /* 1180 * Few simplistic rules and assumptions made here: 1181 * 1. Test bit depth is bit depth per color component 1182 * 2. Assume 3 color components 1183 */ 1184 switch (bpp) { 1185 case 18: 1186 tbd = DP_TEST_BIT_DEPTH_6; 1187 break; 1188 case 24: 1189 tbd = DP_TEST_BIT_DEPTH_8; 1190 break; 1191 case 30: 1192 tbd = DP_TEST_BIT_DEPTH_10; 1193 break; 1194 default: 1195 tbd = DP_TEST_BIT_DEPTH_UNKNOWN; 1196 break; 1197 } 1198 1199 if (tbd != DP_TEST_BIT_DEPTH_UNKNOWN) 1200 tbd = (tbd >> DP_TEST_BIT_DEPTH_SHIFT); 1201 1202 return tbd; 1203 } 1204 1205 struct dp_link *dp_link_get(struct device *dev, struct drm_dp_aux *aux) 1206 { 1207 struct dp_link_private *link; 1208 struct dp_link *dp_link; 1209 1210 if (!dev || !aux) { 1211 DRM_ERROR("invalid input\n"); 1212 return ERR_PTR(-EINVAL); 1213 } 1214 1215 link = devm_kzalloc(dev, sizeof(*link), GFP_KERNEL); 1216 if (!link) 1217 return ERR_PTR(-ENOMEM); 1218 1219 link->dev = dev; 1220 link->aux = aux; 1221 1222 mutex_init(&link->psm_mutex); 1223 dp_link = &link->dp_link; 1224 1225 return dp_link; 1226 } 1227