drivers/gpu/drm/msm/dp/dp_link.c

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