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