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