| // SPDX-License-Identifier: GPL-2.0-only | |
| /* | |
| * Copyright (c) 2012-2020, The Linux Foundation. All rights reserved. | |
| */ | |
| #define pr_fmt(fmt) "[drm-dp] %s: " fmt, __func__ | |
| #include <drm/drm_device.h> | |
| #include <drm/drm_of.h> | |
| #include <drm/drm_print.h> | |
| #include "dp_reg.h" | |
| #include "dp_link.h" | |
| #include "dp_panel.h" | |
| #define DP_LINK_RATE_HBR2 540000 /* kbytes */ | |
| #define DP_TEST_REQUEST_MASK 0x7F | |
| enum audio_sample_rate { | |
| AUDIO_SAMPLE_RATE_32_KHZ = 0x00, | |
| AUDIO_SAMPLE_RATE_44_1_KHZ = 0x01, | |
| AUDIO_SAMPLE_RATE_48_KHZ = 0x02, | |
| AUDIO_SAMPLE_RATE_88_2_KHZ = 0x03, | |
| AUDIO_SAMPLE_RATE_96_KHZ = 0x04, | |
| AUDIO_SAMPLE_RATE_176_4_KHZ = 0x05, | |
| AUDIO_SAMPLE_RATE_192_KHZ = 0x06, | |
| }; | |
| enum audio_pattern_type { | |
| AUDIO_TEST_PATTERN_OPERATOR_DEFINED = 0x00, | |
| AUDIO_TEST_PATTERN_SAWTOOTH = 0x01, | |
| }; | |
| struct msm_dp_link_request { | |
| u32 test_requested; | |
| u32 test_link_rate; | |
| u32 test_lane_count; | |
| }; | |
| struct msm_dp_link_private { | |
| u32 prev_sink_count; | |
| struct drm_device *drm_dev; | |
| struct drm_dp_aux *aux; | |
| struct msm_dp_link msm_dp_link; | |
| struct msm_dp_link_request request; | |
| struct mutex psm_mutex; | |
| u8 link_status[DP_LINK_STATUS_SIZE]; | |
| }; | |
| static int msm_dp_aux_link_power_up(struct drm_dp_aux *aux, | |
| struct msm_dp_link_info *link) | |
| { | |
| u8 value; | |
| ssize_t len; | |
| int i; | |
| if (link->revision < 0x11) | |
| return 0; | |
| len = drm_dp_dpcd_readb(aux, DP_SET_POWER, &value); | |
| if (len < 0) | |
| return len; | |
| value &= ~DP_SET_POWER_MASK; | |
| value |= DP_SET_POWER_D0; | |
| /* retry for 1ms to give the sink time to wake up */ | |
| for (i = 0; i < 3; i++) { | |
| len = drm_dp_dpcd_writeb(aux, DP_SET_POWER, value); | |
| usleep_range(1000, 2000); | |
| if (len == 1) | |
| break; | |
| } | |
| return 0; | |
| } | |
| static int msm_dp_aux_link_power_down(struct drm_dp_aux *aux, | |
| struct msm_dp_link_info *link) | |
| { | |
| u8 value; | |
| int err; | |
| if (link->revision < 0x11) | |
| return 0; | |
| err = drm_dp_dpcd_readb(aux, DP_SET_POWER, &value); | |
| if (err < 0) | |
| return err; | |
| value &= ~DP_SET_POWER_MASK; | |
| value |= DP_SET_POWER_D3; | |
| err = drm_dp_dpcd_writeb(aux, DP_SET_POWER, value); | |
| if (err < 0) | |
| return err; | |
| return 0; | |
| } | |
| static int msm_dp_link_get_period(struct msm_dp_link_private *link, int const addr) | |
| { | |
| int ret = 0; | |
| u8 data; | |
| u32 const max_audio_period = 0xA; | |
| /* TEST_AUDIO_PERIOD_CH_XX */ | |
| if (drm_dp_dpcd_readb(link->aux, addr, &data) < 0) { | |
| DRM_ERROR("failed to read test_audio_period (0x%x)\n", addr); | |
| ret = -EINVAL; | |
| goto exit; | |
| } | |
| /* Period - Bits 3:0 */ | |
| data = data & 0xF; | |
| if ((int)data > max_audio_period) { | |
| DRM_ERROR("invalid test_audio_period_ch_1 = 0x%x\n", data); | |
| ret = -EINVAL; | |
| goto exit; | |
| } | |
| ret = data; | |
| exit: | |
| return ret; | |
| } | |
| static int msm_dp_link_parse_audio_channel_period(struct msm_dp_link_private *link) | |
| { | |
| int ret = 0; | |
| struct msm_dp_link_test_audio *req = &link->msm_dp_link.test_audio; | |
| ret = msm_dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH1); | |
| if (ret == -EINVAL) | |
| goto exit; | |
| req->test_audio_period_ch_1 = ret; | |
| drm_dbg_dp(link->drm_dev, "test_audio_period_ch_1 = 0x%x\n", ret); | |
| ret = msm_dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH2); | |
| if (ret == -EINVAL) | |
| goto exit; | |
| req->test_audio_period_ch_2 = ret; | |
| drm_dbg_dp(link->drm_dev, "test_audio_period_ch_2 = 0x%x\n", ret); | |
| /* TEST_AUDIO_PERIOD_CH_3 (Byte 0x275) */ | |
| ret = msm_dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH3); | |
| if (ret == -EINVAL) | |
| goto exit; | |
| req->test_audio_period_ch_3 = ret; | |
| drm_dbg_dp(link->drm_dev, "test_audio_period_ch_3 = 0x%x\n", ret); | |
| ret = msm_dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH4); | |
| if (ret == -EINVAL) | |
| goto exit; | |
| req->test_audio_period_ch_4 = ret; | |
| drm_dbg_dp(link->drm_dev, "test_audio_period_ch_4 = 0x%x\n", ret); | |
| ret = msm_dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH5); | |
| if (ret == -EINVAL) | |
| goto exit; | |
| req->test_audio_period_ch_5 = ret; | |
| drm_dbg_dp(link->drm_dev, "test_audio_period_ch_5 = 0x%x\n", ret); | |
| ret = msm_dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH6); | |
| if (ret == -EINVAL) | |
| goto exit; | |
| req->test_audio_period_ch_6 = ret; | |
| drm_dbg_dp(link->drm_dev, "test_audio_period_ch_6 = 0x%x\n", ret); | |
| ret = msm_dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH7); | |
| if (ret == -EINVAL) | |
| goto exit; | |
| req->test_audio_period_ch_7 = ret; | |
| drm_dbg_dp(link->drm_dev, "test_audio_period_ch_7 = 0x%x\n", ret); | |
| ret = msm_dp_link_get_period(link, DP_TEST_AUDIO_PERIOD_CH8); | |
| if (ret == -EINVAL) | |
| goto exit; | |
| req->test_audio_period_ch_8 = ret; | |
| drm_dbg_dp(link->drm_dev, "test_audio_period_ch_8 = 0x%x\n", ret); | |
| exit: | |
| return ret; | |
| } | |
| static int msm_dp_link_parse_audio_pattern_type(struct msm_dp_link_private *link) | |
| { | |
| int ret = 0; | |
| u8 data; | |
| ssize_t rlen; | |
| int const max_audio_pattern_type = 0x1; | |
| rlen = drm_dp_dpcd_readb(link->aux, | |
| DP_TEST_AUDIO_PATTERN_TYPE, &data); | |
| if (rlen < 0) { | |
| DRM_ERROR("failed to read link audio mode. rlen=%zd\n", rlen); | |
| return rlen; | |
| } | |
| /* Audio Pattern Type - Bits 7:0 */ | |
| if ((int)data > max_audio_pattern_type) { | |
| DRM_ERROR("invalid audio pattern type = 0x%x\n", data); | |
| ret = -EINVAL; | |
| goto exit; | |
| } | |
| link->msm_dp_link.test_audio.test_audio_pattern_type = data; | |
| drm_dbg_dp(link->drm_dev, "audio pattern type = 0x%x\n", data); | |
| exit: | |
| return ret; | |
| } | |
| static int msm_dp_link_parse_audio_mode(struct msm_dp_link_private *link) | |
| { | |
| int ret = 0; | |
| u8 data; | |
| ssize_t rlen; | |
| int const max_audio_sampling_rate = 0x6; | |
| int const max_audio_channel_count = 0x8; | |
| int sampling_rate = 0x0; | |
| int channel_count = 0x0; | |
| rlen = drm_dp_dpcd_readb(link->aux, DP_TEST_AUDIO_MODE, &data); | |
| if (rlen < 0) { | |
| DRM_ERROR("failed to read link audio mode. rlen=%zd\n", rlen); | |
| return rlen; | |
| } | |
| /* Sampling Rate - Bits 3:0 */ | |
| sampling_rate = data & 0xF; | |
| if (sampling_rate > max_audio_sampling_rate) { | |
| DRM_ERROR("sampling rate (0x%x) greater than max (0x%x)\n", | |
| sampling_rate, max_audio_sampling_rate); | |
| ret = -EINVAL; | |
| goto exit; | |
| } | |
| /* Channel Count - Bits 7:4 */ | |
| channel_count = ((data & 0xF0) >> 4) + 1; | |
| if (channel_count > max_audio_channel_count) { | |
| DRM_ERROR("channel_count (0x%x) greater than max (0x%x)\n", | |
| channel_count, max_audio_channel_count); | |
| ret = -EINVAL; | |
| goto exit; | |
| } | |
| link->msm_dp_link.test_audio.test_audio_sampling_rate = sampling_rate; | |
| link->msm_dp_link.test_audio.test_audio_channel_count = channel_count; | |
| drm_dbg_dp(link->drm_dev, | |
| "sampling_rate = 0x%x, channel_count = 0x%x\n", | |
| sampling_rate, channel_count); | |
| exit: | |
| return ret; | |
| } | |
| static int msm_dp_link_parse_audio_pattern_params(struct msm_dp_link_private *link) | |
| { | |
| int ret = 0; | |
| ret = msm_dp_link_parse_audio_mode(link); | |
| if (ret) | |
| goto exit; | |
| ret = msm_dp_link_parse_audio_pattern_type(link); | |
| if (ret) | |
| goto exit; | |
| ret = msm_dp_link_parse_audio_channel_period(link); | |
| exit: | |
| return ret; | |
| } | |
| static bool msm_dp_link_is_video_pattern_valid(u32 pattern) | |
| { | |
| switch (pattern) { | |
| case DP_NO_TEST_PATTERN: | |
| case DP_COLOR_RAMP: | |
| case DP_BLACK_AND_WHITE_VERTICAL_LINES: | |
| case DP_COLOR_SQUARE: | |
| return true; | |
| default: | |
| return false; | |
| } | |
| } | |
| /** | |
| * msm_dp_link_is_bit_depth_valid() - validates the bit depth requested | |
| * @tbd: bit depth requested by the sink | |
| * | |
| * Returns true if the requested bit depth is supported. | |
| */ | |
| static bool msm_dp_link_is_bit_depth_valid(u32 tbd) | |
| { | |
| /* DP_TEST_VIDEO_PATTERN_NONE is treated as invalid */ | |
| switch (tbd) { | |
| case DP_TEST_BIT_DEPTH_6: | |
| case DP_TEST_BIT_DEPTH_8: | |
| case DP_TEST_BIT_DEPTH_10: | |
| return true; | |
| default: | |
| return false; | |
| } | |
| } | |
| static int msm_dp_link_parse_timing_params1(struct msm_dp_link_private *link, | |
| int addr, int len, u32 *val) | |
| { | |
| u8 bp[2]; | |
| int rlen; | |
| if (len != 2) | |
| return -EINVAL; | |
| /* Read the requested video link pattern (Byte 0x221). */ | |
| rlen = drm_dp_dpcd_read(link->aux, addr, bp, len); | |
| if (rlen < len) { | |
| DRM_ERROR("failed to read 0x%x\n", addr); | |
| return -EINVAL; | |
| } | |
| *val = bp[1] | (bp[0] << 8); | |
| return 0; | |
| } | |
| static int msm_dp_link_parse_timing_params2(struct msm_dp_link_private *link, | |
| int addr, int len, | |
| u32 *val1, u32 *val2) | |
| { | |
| u8 bp[2]; | |
| int rlen; | |
| if (len != 2) | |
| return -EINVAL; | |
| /* Read the requested video link pattern (Byte 0x221). */ | |
| rlen = drm_dp_dpcd_read(link->aux, addr, bp, len); | |
| if (rlen < len) { | |
| DRM_ERROR("failed to read 0x%x\n", addr); | |
| return -EINVAL; | |
| } | |
| *val1 = (bp[0] & BIT(7)) >> 7; | |
| *val2 = bp[1] | ((bp[0] & 0x7F) << 8); | |
| return 0; | |
| } | |
| static int msm_dp_link_parse_timing_params3(struct msm_dp_link_private *link, | |
| int addr, u32 *val) | |
| { | |
| u8 bp; | |
| u32 len = 1; | |
| int rlen; | |
| rlen = drm_dp_dpcd_read(link->aux, addr, &bp, len); | |
| if (rlen < 1) { | |
| DRM_ERROR("failed to read 0x%x\n", addr); | |
| return -EINVAL; | |
| } | |
| *val = bp; | |
| return 0; | |
| } | |
| /** | |
| * msm_dp_link_parse_video_pattern_params() - parses video pattern parameters from DPCD | |
| * @link: Display Port Driver data | |
| * | |
| * Returns 0 if it successfully parses the video link pattern and the link | |
| * bit depth requested by the sink and, and if the values parsed are valid. | |
| */ | |
| static int msm_dp_link_parse_video_pattern_params(struct msm_dp_link_private *link) | |
| { | |
| int ret = 0; | |
| ssize_t rlen; | |
| u8 bp; | |
| rlen = drm_dp_dpcd_readb(link->aux, DP_TEST_PATTERN, &bp); | |
| if (rlen < 0) { | |
| DRM_ERROR("failed to read link video pattern. rlen=%zd\n", | |
| rlen); | |
| return rlen; | |
| } | |
| if (!msm_dp_link_is_video_pattern_valid(bp)) { | |
| DRM_ERROR("invalid link video pattern = 0x%x\n", bp); | |
| ret = -EINVAL; | |
| return ret; | |
| } | |
| link->msm_dp_link.test_video.test_video_pattern = bp; | |
| /* Read the requested color bit depth and dynamic range (Byte 0x232) */ | |
| rlen = drm_dp_dpcd_readb(link->aux, DP_TEST_MISC0, &bp); | |
| if (rlen < 0) { | |
| DRM_ERROR("failed to read link bit depth. rlen=%zd\n", rlen); | |
| return rlen; | |
| } | |
| /* Dynamic Range */ | |
| link->msm_dp_link.test_video.test_dyn_range = | |
| (bp & DP_TEST_DYNAMIC_RANGE_CEA); | |
| /* Color bit depth */ | |
| bp &= DP_TEST_BIT_DEPTH_MASK; | |
| if (!msm_dp_link_is_bit_depth_valid(bp)) { | |
| DRM_ERROR("invalid link bit depth = 0x%x\n", bp); | |
| ret = -EINVAL; | |
| return ret; | |
| } | |
| link->msm_dp_link.test_video.test_bit_depth = bp; | |
| /* resolution timing params */ | |
| ret = msm_dp_link_parse_timing_params1(link, DP_TEST_H_TOTAL_HI, 2, | |
| &link->msm_dp_link.test_video.test_h_total); | |
| if (ret) { | |
| DRM_ERROR("failed to parse test_htotal(DP_TEST_H_TOTAL_HI)\n"); | |
| return ret; | |
| } | |
| ret = msm_dp_link_parse_timing_params1(link, DP_TEST_V_TOTAL_HI, 2, | |
| &link->msm_dp_link.test_video.test_v_total); | |
| if (ret) { | |
| DRM_ERROR("failed to parse test_v_total(DP_TEST_V_TOTAL_HI)\n"); | |
| return ret; | |
| } | |
| ret = msm_dp_link_parse_timing_params1(link, DP_TEST_H_START_HI, 2, | |
| &link->msm_dp_link.test_video.test_h_start); | |
| if (ret) { | |
| DRM_ERROR("failed to parse test_h_start(DP_TEST_H_START_HI)\n"); | |
| return ret; | |
| } | |
| ret = msm_dp_link_parse_timing_params1(link, DP_TEST_V_START_HI, 2, | |
| &link->msm_dp_link.test_video.test_v_start); | |
| if (ret) { | |
| DRM_ERROR("failed to parse test_v_start(DP_TEST_V_START_HI)\n"); | |
| return ret; | |
| } | |
| ret = msm_dp_link_parse_timing_params2(link, DP_TEST_HSYNC_HI, 2, | |
| &link->msm_dp_link.test_video.test_hsync_pol, | |
| &link->msm_dp_link.test_video.test_hsync_width); | |
| if (ret) { | |
| DRM_ERROR("failed to parse (DP_TEST_HSYNC_HI)\n"); | |
| return ret; | |
| } | |
| ret = msm_dp_link_parse_timing_params2(link, DP_TEST_VSYNC_HI, 2, | |
| &link->msm_dp_link.test_video.test_vsync_pol, | |
| &link->msm_dp_link.test_video.test_vsync_width); | |
| if (ret) { | |
| DRM_ERROR("failed to parse (DP_TEST_VSYNC_HI)\n"); | |
| return ret; | |
| } | |
| ret = msm_dp_link_parse_timing_params1(link, DP_TEST_H_WIDTH_HI, 2, | |
| &link->msm_dp_link.test_video.test_h_width); | |
| if (ret) { | |
| DRM_ERROR("failed to parse test_h_width(DP_TEST_H_WIDTH_HI)\n"); | |
| return ret; | |
| } | |
| ret = msm_dp_link_parse_timing_params1(link, DP_TEST_V_HEIGHT_HI, 2, | |
| &link->msm_dp_link.test_video.test_v_height); | |
| if (ret) { | |
| DRM_ERROR("failed to parse test_v_height\n"); | |
| return ret; | |
| } | |
| ret = msm_dp_link_parse_timing_params3(link, DP_TEST_MISC1, | |
| &link->msm_dp_link.test_video.test_rr_d); | |
| link->msm_dp_link.test_video.test_rr_d &= DP_TEST_REFRESH_DENOMINATOR; | |
| if (ret) { | |
| DRM_ERROR("failed to parse test_rr_d (DP_TEST_MISC1)\n"); | |
| return ret; | |
| } | |
| ret = msm_dp_link_parse_timing_params3(link, DP_TEST_REFRESH_RATE_NUMERATOR, | |
| &link->msm_dp_link.test_video.test_rr_n); | |
| if (ret) { | |
| DRM_ERROR("failed to parse test_rr_n\n"); | |
| return ret; | |
| } | |
| drm_dbg_dp(link->drm_dev, | |
| "link video pattern = 0x%x\n" | |
| "link dynamic range = 0x%x\n" | |
| "link bit depth = 0x%x\n" | |
| "TEST_H_TOTAL = %d, TEST_V_TOTAL = %d\n" | |
| "TEST_H_START = %d, TEST_V_START = %d\n" | |
| "TEST_HSYNC_POL = %d\n" | |
| "TEST_HSYNC_WIDTH = %d\n" | |
| "TEST_VSYNC_POL = %d\n" | |
| "TEST_VSYNC_WIDTH = %d\n" | |
| "TEST_H_WIDTH = %d\n" | |
| "TEST_V_HEIGHT = %d\n" | |
| "TEST_REFRESH_DENOMINATOR = %d\n" | |
| "TEST_REFRESH_NUMERATOR = %d\n", | |
| link->msm_dp_link.test_video.test_video_pattern, | |
| link->msm_dp_link.test_video.test_dyn_range, | |
| link->msm_dp_link.test_video.test_bit_depth, | |
| link->msm_dp_link.test_video.test_h_total, | |
| link->msm_dp_link.test_video.test_v_total, | |
| link->msm_dp_link.test_video.test_h_start, | |
| link->msm_dp_link.test_video.test_v_start, | |
| link->msm_dp_link.test_video.test_hsync_pol, | |
| link->msm_dp_link.test_video.test_hsync_width, | |
| link->msm_dp_link.test_video.test_vsync_pol, | |
| link->msm_dp_link.test_video.test_vsync_width, | |
| link->msm_dp_link.test_video.test_h_width, | |
| link->msm_dp_link.test_video.test_v_height, | |
| link->msm_dp_link.test_video.test_rr_d, | |
| link->msm_dp_link.test_video.test_rr_n); | |
| return ret; | |
| } | |
| /** | |
| * msm_dp_link_parse_link_training_params() - parses link training parameters from | |
| * DPCD | |
| * @link: Display Port Driver data | |
| * | |
| * Returns 0 if it successfully parses the link rate (Byte 0x219) and lane | |
| * count (Byte 0x220), and if these values parse are valid. | |
| */ | |
| static int msm_dp_link_parse_link_training_params(struct msm_dp_link_private *link) | |
| { | |
| u8 bp; | |
| ssize_t rlen; | |
| rlen = drm_dp_dpcd_readb(link->aux, DP_TEST_LINK_RATE, &bp); | |
| if (rlen < 0) { | |
| DRM_ERROR("failed to read link rate. rlen=%zd\n", rlen); | |
| return rlen; | |
| } | |
| if (!is_link_rate_valid(bp)) { | |
| DRM_ERROR("invalid link rate = 0x%x\n", bp); | |
| return -EINVAL; | |
| } | |
| link->request.test_link_rate = bp; | |
| drm_dbg_dp(link->drm_dev, "link rate = 0x%x\n", | |
| link->request.test_link_rate); | |
| rlen = drm_dp_dpcd_readb(link->aux, DP_TEST_LANE_COUNT, &bp); | |
| if (rlen < 0) { | |
| DRM_ERROR("failed to read lane count. rlen=%zd\n", rlen); | |
| return rlen; | |
| } | |
| bp &= DP_MAX_LANE_COUNT_MASK; | |
| if (!is_lane_count_valid(bp)) { | |
| DRM_ERROR("invalid lane count = 0x%x\n", bp); | |
| return -EINVAL; | |
| } | |
| link->request.test_lane_count = bp; | |
| drm_dbg_dp(link->drm_dev, "lane count = 0x%x\n", | |
| link->request.test_lane_count); | |
| return 0; | |
| } | |
| /** | |
| * msm_dp_link_parse_phy_test_params() - parses the phy link parameters | |
| * @link: Display Port Driver data | |
| * | |
| * Parses the DPCD (Byte 0x248) for the DP PHY link pattern that is being | |
| * requested. | |
| */ | |
| static int msm_dp_link_parse_phy_test_params(struct msm_dp_link_private *link) | |
| { | |
| u8 data; | |
| ssize_t rlen; | |
| rlen = drm_dp_dpcd_readb(link->aux, DP_PHY_TEST_PATTERN, | |
| &data); | |
| if (rlen < 0) { | |
| DRM_ERROR("failed to read phy link pattern. rlen=%zd\n", rlen); | |
| return rlen; | |
| } | |
| link->msm_dp_link.phy_params.phy_test_pattern_sel = data & 0x07; | |
| drm_dbg_dp(link->drm_dev, "phy_test_pattern_sel = 0x%x\n", data); | |
| switch (data) { | |
| case DP_PHY_TEST_PATTERN_SEL_MASK: | |
| case DP_PHY_TEST_PATTERN_NONE: | |
| case DP_PHY_TEST_PATTERN_D10_2: | |
| case DP_PHY_TEST_PATTERN_ERROR_COUNT: | |
| case DP_PHY_TEST_PATTERN_PRBS7: | |
| case DP_PHY_TEST_PATTERN_80BIT_CUSTOM: | |
| case DP_PHY_TEST_PATTERN_CP2520: | |
| return 0; | |
| default: | |
| return -EINVAL; | |
| } | |
| } | |
| /** | |
| * msm_dp_link_is_video_audio_test_requested() - checks for audio/video link request | |
| * @link: link requested by the sink | |
| * | |
| * Returns true if the requested link is a permitted audio/video link. | |
| */ | |
| static bool msm_dp_link_is_video_audio_test_requested(u32 link) | |
| { | |
| u8 video_audio_test = (DP_TEST_LINK_VIDEO_PATTERN | | |
| DP_TEST_LINK_AUDIO_PATTERN | | |
| DP_TEST_LINK_AUDIO_DISABLED_VIDEO); | |
| return ((link & video_audio_test) && | |
| !(link & ~video_audio_test)); | |
| } | |
| /** | |
| * msm_dp_link_parse_request() - parses link request parameters from sink | |
| * @link: Display Port Driver data | |
| * | |
| * Parses the DPCD to check if an automated link is requested (Byte 0x201), | |
| * and what type of link automation is being requested (Byte 0x218). | |
| */ | |
| static int msm_dp_link_parse_request(struct msm_dp_link_private *link) | |
| { | |
| int ret = 0; | |
| u8 data; | |
| ssize_t rlen; | |
| /** | |
| * Read the device service IRQ vector (Byte 0x201) to determine | |
| * whether an automated link has been requested by the sink. | |
| */ | |
| rlen = drm_dp_dpcd_readb(link->aux, | |
| DP_DEVICE_SERVICE_IRQ_VECTOR, &data); | |
| if (rlen < 0) { | |
| DRM_ERROR("aux read failed. rlen=%zd\n", rlen); | |
| return rlen; | |
| } | |
| drm_dbg_dp(link->drm_dev, "device service irq vector = 0x%x\n", data); | |
| if (!(data & DP_AUTOMATED_TEST_REQUEST)) { | |
| drm_dbg_dp(link->drm_dev, "no test requested\n"); | |
| return 0; | |
| } | |
| /** | |
| * Read the link request byte (Byte 0x218) to determine what type | |
| * of automated link has been requested by the sink. | |
| */ | |
| rlen = drm_dp_dpcd_readb(link->aux, DP_TEST_REQUEST, &data); | |
| if (rlen < 0) { | |
| DRM_ERROR("aux read failed. rlen=%zd\n", rlen); | |
| return rlen; | |
| } | |
| if (!data || (data == DP_TEST_LINK_FAUX_PATTERN)) { | |
| drm_dbg_dp(link->drm_dev, "link 0x%x not supported\n", data); | |
| goto end; | |
| } | |
| drm_dbg_dp(link->drm_dev, "Test:(0x%x) requested\n", data); | |
| link->request.test_requested = data; | |
| if (link->request.test_requested == DP_TEST_LINK_PHY_TEST_PATTERN) { | |
| ret = msm_dp_link_parse_phy_test_params(link); | |
| if (ret) | |
| goto end; | |
| ret = msm_dp_link_parse_link_training_params(link); | |
| if (ret) | |
| goto end; | |
| } | |
| if (link->request.test_requested == DP_TEST_LINK_TRAINING) { | |
| ret = msm_dp_link_parse_link_training_params(link); | |
| if (ret) | |
| goto end; | |
| } | |
| if (msm_dp_link_is_video_audio_test_requested( | |
| link->request.test_requested)) { | |
| ret = msm_dp_link_parse_video_pattern_params(link); | |
| if (ret) | |
| goto end; | |
| ret = msm_dp_link_parse_audio_pattern_params(link); | |
| } | |
| end: | |
| /* | |
| * Send a DP_TEST_ACK if all link parameters are valid, otherwise send | |
| * a DP_TEST_NAK. | |
| */ | |
| if (ret) { | |
| link->msm_dp_link.test_response = DP_TEST_NAK; | |
| } else { | |
| if (link->request.test_requested != DP_TEST_LINK_EDID_READ) | |
| link->msm_dp_link.test_response = DP_TEST_ACK; | |
| else | |
| link->msm_dp_link.test_response = | |
| DP_TEST_EDID_CHECKSUM_WRITE; | |
| } | |
| return ret; | |
| } | |
| static int msm_dp_link_parse_sink_status_field(struct msm_dp_link_private *link) | |
| { | |
| int ret; | |
| link->prev_sink_count = link->msm_dp_link.sink_count; | |
| ret = drm_dp_read_sink_count(link->aux); | |
| if (ret < 0) { | |
| DRM_ERROR("DP parse sink count failed\n"); | |
| return ret; | |
| } | |
| link->msm_dp_link.sink_count = ret; | |
| ret = drm_dp_dpcd_read_link_status(link->aux, | |
| link->link_status); | |
| if (ret < 0) { | |
| DRM_ERROR("DP link status read failed\n"); | |
| return ret; | |
| } | |
| return msm_dp_link_parse_request(link); | |
| } | |
| /** | |
| * msm_dp_link_process_link_training_request() - processes new training requests | |
| * @link: Display Port link data | |
| * | |
| * This function will handle new link training requests that are initiated by | |
| * the sink. In particular, it will update the requested lane count and link | |
| * rate, and then trigger the link retraining procedure. | |
| * | |
| * The function will return 0 if a link training request has been processed, | |
| * otherwise it will return -EINVAL. | |
| */ | |
| static int msm_dp_link_process_link_training_request(struct msm_dp_link_private *link) | |
| { | |
| if (link->request.test_requested != DP_TEST_LINK_TRAINING) | |
| return -EINVAL; | |
| drm_dbg_dp(link->drm_dev, | |
| "Test:0x%x link rate = 0x%x, lane count = 0x%x\n", | |
| DP_TEST_LINK_TRAINING, | |
| link->request.test_link_rate, | |
| link->request.test_lane_count); | |
| link->msm_dp_link.link_params.num_lanes = link->request.test_lane_count; | |
| link->msm_dp_link.link_params.rate = | |
| drm_dp_bw_code_to_link_rate(link->request.test_link_rate); | |
| return 0; | |
| } | |
| bool msm_dp_link_send_test_response(struct msm_dp_link *msm_dp_link) | |
| { | |
| struct msm_dp_link_private *link = NULL; | |
| int ret = 0; | |
| if (!msm_dp_link) { | |
| DRM_ERROR("invalid input\n"); | |
| return false; | |
| } | |
| link = container_of(msm_dp_link, struct msm_dp_link_private, msm_dp_link); | |
| ret = drm_dp_dpcd_writeb(link->aux, DP_TEST_RESPONSE, | |
| msm_dp_link->test_response); | |
| return ret == 1; | |
| } | |
| int msm_dp_link_psm_config(struct msm_dp_link *msm_dp_link, | |
| struct msm_dp_link_info *link_info, bool enable) | |
| { | |
| struct msm_dp_link_private *link = NULL; | |
| int ret = 0; | |
| if (!msm_dp_link) { | |
| DRM_ERROR("invalid params\n"); | |
| return -EINVAL; | |
| } | |
| link = container_of(msm_dp_link, struct msm_dp_link_private, msm_dp_link); | |
| mutex_lock(&link->psm_mutex); | |
| if (enable) | |
| ret = msm_dp_aux_link_power_down(link->aux, link_info); | |
| else | |
| ret = msm_dp_aux_link_power_up(link->aux, link_info); | |
| if (ret) | |
| DRM_ERROR("Failed to %s low power mode\n", enable ? | |
| "enter" : "exit"); | |
| mutex_unlock(&link->psm_mutex); | |
| return ret; | |
| } | |
| bool msm_dp_link_send_edid_checksum(struct msm_dp_link *msm_dp_link, u8 checksum) | |
| { | |
| struct msm_dp_link_private *link = NULL; | |
| int ret = 0; | |
| if (!msm_dp_link) { | |
| DRM_ERROR("invalid input\n"); | |
| return false; | |
| } | |
| link = container_of(msm_dp_link, struct msm_dp_link_private, msm_dp_link); | |
| ret = drm_dp_dpcd_writeb(link->aux, DP_TEST_EDID_CHECKSUM, | |
| checksum); | |
| return ret == 1; | |
| } | |
| static void msm_dp_link_parse_vx_px(struct msm_dp_link_private *link) | |
| { | |
| drm_dbg_dp(link->drm_dev, "vx: 0=%d, 1=%d, 2=%d, 3=%d\n", | |
| drm_dp_get_adjust_request_voltage(link->link_status, 0), | |
| drm_dp_get_adjust_request_voltage(link->link_status, 1), | |
| drm_dp_get_adjust_request_voltage(link->link_status, 2), | |
| drm_dp_get_adjust_request_voltage(link->link_status, 3)); | |
| drm_dbg_dp(link->drm_dev, "px: 0=%d, 1=%d, 2=%d, 3=%d\n", | |
| drm_dp_get_adjust_request_pre_emphasis(link->link_status, 0), | |
| drm_dp_get_adjust_request_pre_emphasis(link->link_status, 1), | |
| drm_dp_get_adjust_request_pre_emphasis(link->link_status, 2), | |
| drm_dp_get_adjust_request_pre_emphasis(link->link_status, 3)); | |
| /** | |
| * Update the voltage and pre-emphasis levels as per DPCD request | |
| * vector. | |
| */ | |
| drm_dbg_dp(link->drm_dev, | |
| "Current: v_level = 0x%x, p_level = 0x%x\n", | |
| link->msm_dp_link.phy_params.v_level, | |
| link->msm_dp_link.phy_params.p_level); | |
| link->msm_dp_link.phy_params.v_level = | |
| drm_dp_get_adjust_request_voltage(link->link_status, 0); | |
| link->msm_dp_link.phy_params.p_level = | |
| drm_dp_get_adjust_request_pre_emphasis(link->link_status, 0); | |
| link->msm_dp_link.phy_params.p_level >>= DP_TRAIN_PRE_EMPHASIS_SHIFT; | |
| drm_dbg_dp(link->drm_dev, | |
| "Requested: v_level = 0x%x, p_level = 0x%x\n", | |
| link->msm_dp_link.phy_params.v_level, | |
| link->msm_dp_link.phy_params.p_level); | |
| } | |
| /** | |
| * msm_dp_link_process_phy_test_pattern_request() - process new phy link requests | |
| * @link: Display Port Driver data | |
| * | |
| * This function will handle new phy link pattern requests that are initiated | |
| * by the sink. The function will return 0 if a phy link pattern has been | |
| * processed, otherwise it will return -EINVAL. | |
| */ | |
| static int msm_dp_link_process_phy_test_pattern_request( | |
| struct msm_dp_link_private *link) | |
| { | |
| if (!(link->request.test_requested & DP_TEST_LINK_PHY_TEST_PATTERN)) { | |
| drm_dbg_dp(link->drm_dev, "no phy test\n"); | |
| return -EINVAL; | |
| } | |
| if (!is_link_rate_valid(link->request.test_link_rate) || | |
| !is_lane_count_valid(link->request.test_lane_count)) { | |
| DRM_ERROR("Invalid: link rate = 0x%x,lane count = 0x%x\n", | |
| link->request.test_link_rate, | |
| link->request.test_lane_count); | |
| return -EINVAL; | |
| } | |
| drm_dbg_dp(link->drm_dev, | |
| "Current: rate = 0x%x, lane count = 0x%x\n", | |
| link->msm_dp_link.link_params.rate, | |
| link->msm_dp_link.link_params.num_lanes); | |
| drm_dbg_dp(link->drm_dev, | |
| "Requested: rate = 0x%x, lane count = 0x%x\n", | |
| link->request.test_link_rate, | |
| link->request.test_lane_count); | |
| link->msm_dp_link.link_params.num_lanes = link->request.test_lane_count; | |
| link->msm_dp_link.link_params.rate = | |
| drm_dp_bw_code_to_link_rate(link->request.test_link_rate); | |
| msm_dp_link_parse_vx_px(link); | |
| return 0; | |
| } | |
| static bool msm_dp_link_read_psr_error_status(struct msm_dp_link_private *link) | |
| { | |
| u8 status; | |
| drm_dp_dpcd_read(link->aux, DP_PSR_ERROR_STATUS, &status, 1); | |
| if (status & DP_PSR_LINK_CRC_ERROR) | |
| DRM_ERROR("PSR LINK CRC ERROR\n"); | |
| else if (status & DP_PSR_RFB_STORAGE_ERROR) | |
| DRM_ERROR("PSR RFB STORAGE ERROR\n"); | |
| else if (status & DP_PSR_VSC_SDP_UNCORRECTABLE_ERROR) | |
| DRM_ERROR("PSR VSC SDP UNCORRECTABLE ERROR\n"); | |
| else | |
| return false; | |
| return true; | |
| } | |
| static bool msm_dp_link_psr_capability_changed(struct msm_dp_link_private *link) | |
| { | |
| u8 status; | |
| drm_dp_dpcd_read(link->aux, DP_PSR_ESI, &status, 1); | |
| if (status & DP_PSR_CAPS_CHANGE) { | |
| drm_dbg_dp(link->drm_dev, "PSR Capability Change\n"); | |
| return true; | |
| } | |
| return false; | |
| } | |
| static u8 get_link_status(const u8 link_status[DP_LINK_STATUS_SIZE], int r) | |
| { | |
| return link_status[r - DP_LANE0_1_STATUS]; | |
| } | |
| /** | |
| * msm_dp_link_process_link_status_update() - processes link status updates | |
| * @link: Display Port link module data | |
| * | |
| * This function will check for changes in the link status, e.g. clock | |
| * recovery done on all lanes, and trigger link training if there is a | |
| * failure/error on the link. | |
| * | |
| * The function will return 0 if the a link status update has been processed, | |
| * otherwise it will return -EINVAL. | |
| */ | |
| static int msm_dp_link_process_link_status_update(struct msm_dp_link_private *link) | |
| { | |
| bool channel_eq_done = drm_dp_channel_eq_ok(link->link_status, | |
| link->msm_dp_link.link_params.num_lanes); | |
| bool clock_recovery_done = drm_dp_clock_recovery_ok(link->link_status, | |
| link->msm_dp_link.link_params.num_lanes); | |
| drm_dbg_dp(link->drm_dev, | |
| "channel_eq_done = %d, clock_recovery_done = %d\n", | |
| channel_eq_done, clock_recovery_done); | |
| if (channel_eq_done && clock_recovery_done) | |
| return -EINVAL; | |
| return 0; | |
| } | |
| /** | |
| * msm_dp_link_process_ds_port_status_change() - process port status changes | |
| * @link: Display Port Driver data | |
| * | |
| * This function will handle downstream port updates that are initiated by | |
| * the sink. If the downstream port status has changed, the EDID is read via | |
| * AUX. | |
| * | |
| * The function will return 0 if a downstream port update has been | |
| * processed, otherwise it will return -EINVAL. | |
| */ | |
| static int msm_dp_link_process_ds_port_status_change(struct msm_dp_link_private *link) | |
| { | |
| if (get_link_status(link->link_status, DP_LANE_ALIGN_STATUS_UPDATED) & | |
| DP_DOWNSTREAM_PORT_STATUS_CHANGED) | |
| goto reset; | |
| if (link->prev_sink_count == link->msm_dp_link.sink_count) | |
| return -EINVAL; | |
| reset: | |
| /* reset prev_sink_count */ | |
| link->prev_sink_count = link->msm_dp_link.sink_count; | |
| return 0; | |
| } | |
| static bool msm_dp_link_is_video_pattern_requested(struct msm_dp_link_private *link) | |
| { | |
| return (link->request.test_requested & DP_TEST_LINK_VIDEO_PATTERN) | |
| && !(link->request.test_requested & | |
| DP_TEST_LINK_AUDIO_DISABLED_VIDEO); | |
| } | |
| static bool msm_dp_link_is_audio_pattern_requested(struct msm_dp_link_private *link) | |
| { | |
| return (link->request.test_requested & DP_TEST_LINK_AUDIO_PATTERN); | |
| } | |
| static void msm_dp_link_reset_data(struct msm_dp_link_private *link) | |
| { | |
| link->request = (const struct msm_dp_link_request){ 0 }; | |
| link->msm_dp_link.test_video = (const struct msm_dp_link_test_video){ 0 }; | |
| link->msm_dp_link.test_video.test_bit_depth = DP_TEST_BIT_DEPTH_UNKNOWN; | |
| link->msm_dp_link.test_audio = (const struct msm_dp_link_test_audio){ 0 }; | |
| link->msm_dp_link.phy_params.phy_test_pattern_sel = 0; | |
| link->msm_dp_link.sink_request = 0; | |
| link->msm_dp_link.test_response = 0; | |
| } | |
| /** | |
| * msm_dp_link_process_request() - handle HPD IRQ transition to HIGH | |
| * @msm_dp_link: pointer to link module data | |
| * | |
| * This function will handle the HPD IRQ state transitions from LOW to HIGH | |
| * (including cases when there are back to back HPD IRQ HIGH) indicating | |
| * the start of a new link training request or sink status update. | |
| */ | |
| int msm_dp_link_process_request(struct msm_dp_link *msm_dp_link) | |
| { | |
| int ret = 0; | |
| struct msm_dp_link_private *link; | |
| if (!msm_dp_link) { | |
| DRM_ERROR("invalid input\n"); | |
| return -EINVAL; | |
| } | |
| link = container_of(msm_dp_link, struct msm_dp_link_private, msm_dp_link); | |
| msm_dp_link_reset_data(link); | |
| ret = msm_dp_link_parse_sink_status_field(link); | |
| if (ret) | |
| return ret; | |
| if (link->request.test_requested == DP_TEST_LINK_EDID_READ) { | |
| msm_dp_link->sink_request |= DP_TEST_LINK_EDID_READ; | |
| } else if (!msm_dp_link_process_ds_port_status_change(link)) { | |
| msm_dp_link->sink_request |= DS_PORT_STATUS_CHANGED; | |
| } else if (!msm_dp_link_process_link_training_request(link)) { | |
| msm_dp_link->sink_request |= DP_TEST_LINK_TRAINING; | |
| } else if (!msm_dp_link_process_phy_test_pattern_request(link)) { | |
| msm_dp_link->sink_request |= DP_TEST_LINK_PHY_TEST_PATTERN; | |
| } else if (msm_dp_link_read_psr_error_status(link)) { | |
| DRM_ERROR("PSR IRQ_HPD received\n"); | |
| } else if (msm_dp_link_psr_capability_changed(link)) { | |
| drm_dbg_dp(link->drm_dev, "PSR Capability changed\n"); | |
| } else { | |
| ret = msm_dp_link_process_link_status_update(link); | |
| if (!ret) { | |
| msm_dp_link->sink_request |= DP_LINK_STATUS_UPDATED; | |
| } else { | |
| if (msm_dp_link_is_video_pattern_requested(link)) { | |
| ret = 0; | |
| msm_dp_link->sink_request |= DP_TEST_LINK_VIDEO_PATTERN; | |
| } | |
| if (msm_dp_link_is_audio_pattern_requested(link)) { | |
| msm_dp_link->sink_request |= DP_TEST_LINK_AUDIO_PATTERN; | |
| ret = -EINVAL; | |
| } | |
| } | |
| } | |
| drm_dbg_dp(link->drm_dev, "sink request=%#x\n", | |
| msm_dp_link->sink_request); | |
| return ret; | |
| } | |
| int msm_dp_link_get_colorimetry_config(struct msm_dp_link *msm_dp_link) | |
| { | |
| u32 cc = DP_MISC0_COLORIMERY_CFG_LEGACY_RGB; | |
| struct msm_dp_link_private *link; | |
| if (!msm_dp_link) { | |
| DRM_ERROR("invalid input\n"); | |
| return -EINVAL; | |
| } | |
| link = container_of(msm_dp_link, struct msm_dp_link_private, msm_dp_link); | |
| /* | |
| * Unless a video pattern CTS test is ongoing, use RGB_VESA | |
| * Only RGB_VESA and RGB_CEA supported for now | |
| */ | |
| if (msm_dp_link_is_video_pattern_requested(link)) { | |
| if (link->msm_dp_link.test_video.test_dyn_range & | |
| DP_TEST_DYNAMIC_RANGE_CEA) | |
| cc = DP_MISC0_COLORIMERY_CFG_CEA_RGB; | |
| } | |
| return cc; | |
| } | |
| int msm_dp_link_adjust_levels(struct msm_dp_link *msm_dp_link, u8 *link_status) | |
| { | |
| int i; | |
| u8 max_p_level; | |
| int v_max = 0, p_max = 0; | |
| struct msm_dp_link_private *link; | |
| if (!msm_dp_link) { | |
| DRM_ERROR("invalid input\n"); | |
| return -EINVAL; | |
| } | |
| link = container_of(msm_dp_link, struct msm_dp_link_private, msm_dp_link); | |
| /* use the max level across lanes */ | |
| for (i = 0; i < msm_dp_link->link_params.num_lanes; i++) { | |
| u8 data_v = drm_dp_get_adjust_request_voltage(link_status, i); | |
| u8 data_p = drm_dp_get_adjust_request_pre_emphasis(link_status, | |
| i); | |
| drm_dbg_dp(link->drm_dev, | |
| "lane=%d req_vol_swing=%d req_pre_emphasis=%d\n", | |
| i, data_v, data_p); | |
| if (v_max < data_v) | |
| v_max = data_v; | |
| if (p_max < data_p) | |
| p_max = data_p; | |
| } | |
| msm_dp_link->phy_params.v_level = v_max >> DP_TRAIN_VOLTAGE_SWING_SHIFT; | |
| msm_dp_link->phy_params.p_level = p_max >> DP_TRAIN_PRE_EMPHASIS_SHIFT; | |
| /** | |
| * Adjust the voltage swing and pre-emphasis level combination to within | |
| * the allowable range. | |
| */ | |
| if (msm_dp_link->phy_params.v_level > DP_TRAIN_LEVEL_MAX) { | |
| drm_dbg_dp(link->drm_dev, | |
| "Requested vSwingLevel=%d, change to %d\n", | |
| msm_dp_link->phy_params.v_level, | |
| DP_TRAIN_LEVEL_MAX); | |
| msm_dp_link->phy_params.v_level = DP_TRAIN_LEVEL_MAX; | |
| } | |
| if (msm_dp_link->phy_params.p_level > DP_TRAIN_LEVEL_MAX) { | |
| drm_dbg_dp(link->drm_dev, | |
| "Requested preEmphasisLevel=%d, change to %d\n", | |
| msm_dp_link->phy_params.p_level, | |
| DP_TRAIN_LEVEL_MAX); | |
| msm_dp_link->phy_params.p_level = DP_TRAIN_LEVEL_MAX; | |
| } | |
| max_p_level = DP_TRAIN_LEVEL_MAX - msm_dp_link->phy_params.v_level; | |
| if (msm_dp_link->phy_params.p_level > max_p_level) { | |
| drm_dbg_dp(link->drm_dev, | |
| "Requested preEmphasisLevel=%d, change to %d\n", | |
| msm_dp_link->phy_params.p_level, | |
| max_p_level); | |
| msm_dp_link->phy_params.p_level = max_p_level; | |
| } | |
| drm_dbg_dp(link->drm_dev, "adjusted: v_level=%d, p_level=%d\n", | |
| msm_dp_link->phy_params.v_level, msm_dp_link->phy_params.p_level); | |
| return 0; | |
| } | |
| void msm_dp_link_reset_phy_params_vx_px(struct msm_dp_link *msm_dp_link) | |
| { | |
| msm_dp_link->phy_params.v_level = 0; | |
| msm_dp_link->phy_params.p_level = 0; | |
| } | |
| u32 msm_dp_link_get_test_bits_depth(struct msm_dp_link *msm_dp_link, u32 bpp) | |
| { | |
| u32 tbd; | |
| struct msm_dp_link_private *link; | |
| link = container_of(msm_dp_link, struct msm_dp_link_private, msm_dp_link); | |
| /* | |
| * Few simplistic rules and assumptions made here: | |
| * 1. Test bit depth is bit depth per color component | |
| * 2. Assume 3 color components | |
| */ | |
| switch (bpp) { | |
| case 18: | |
| tbd = DP_TEST_BIT_DEPTH_6; | |
| break; | |
| case 24: | |
| tbd = DP_TEST_BIT_DEPTH_8; | |
| break; | |
| case 30: | |
| tbd = DP_TEST_BIT_DEPTH_10; | |
| break; | |
| default: | |
| drm_dbg_dp(link->drm_dev, "bpp=%d not supported, use bpc=8\n", | |
| bpp); | |
| tbd = DP_TEST_BIT_DEPTH_8; | |
| break; | |
| } | |
| tbd = (tbd >> DP_TEST_BIT_DEPTH_SHIFT); | |
| return tbd; | |
| } | |
| static u32 msm_dp_link_link_frequencies(struct device_node *of_node) | |
| { | |
| struct device_node *endpoint; | |
| u64 frequency = 0; | |
| int cnt; | |
| endpoint = of_graph_get_endpoint_by_regs(of_node, 1, 0); /* port@1 */ | |
| if (!endpoint) | |
| return 0; | |
| cnt = of_property_count_u64_elems(endpoint, "link-frequencies"); | |
| if (cnt > 0) | |
| of_property_read_u64_index(endpoint, "link-frequencies", | |
| cnt - 1, &frequency); | |
| of_node_put(endpoint); | |
| do_div(frequency, | |
| 10 * /* from symbol rate to link rate */ | |
| 1000); /* kbytes */ | |
| return frequency; | |
| } | |
| /* | |
| * Always populate msm_dp_link->lane_map with 4 lanes. | |
| * - Use DTS "data-lanes" if present; otherwise fall back to default mapping. | |
| * - For partial definitions, fill remaining entries with unused lanes in | |
| * ascending order. | |
| */ | |
| static int msm_dp_link_lane_map(struct device *dev, struct msm_dp_link *msm_dp_link) | |
| { | |
| struct device_node *of_node = dev->of_node; | |
| struct device_node *endpoint; | |
| int cnt = msm_dp_link->max_dp_lanes; | |
| u32 tmp[DP_MAX_NUM_DP_LANES]; | |
| u32 map[DP_MAX_NUM_DP_LANES] = {0, 1, 2, 3}; /* default 1:1 mapping */ | |
| bool used[DP_MAX_NUM_DP_LANES] = {false}; | |
| int i, j = 0, ret = -EINVAL; | |
| endpoint = of_graph_get_endpoint_by_regs(of_node, 1, -1); | |
| if (endpoint) { | |
| ret = of_property_read_u32_array(endpoint, "data-lanes", tmp, cnt); | |
| if (ret) | |
| dev_dbg(dev, "endpoint data-lanes read failed (ret=%d)\n", ret); | |
| } | |
| if (ret) { | |
| ret = of_property_read_u32_array(of_node, "data-lanes", tmp, cnt); | |
| if (ret) { | |
| dev_info(dev, "data-lanes not defined, set to default\n"); | |
| goto out; | |
| } | |
| } | |
| for (i = 0; i < cnt; i++) { | |
| if (tmp[i] >= DP_MAX_NUM_DP_LANES) { | |
| dev_err(dev, "data-lanes[%d]=%u out of range\n", i, tmp[i]); | |
| return -EINVAL; | |
| } | |
| used[tmp[i]] = true; | |
| map[i] = tmp[i]; | |
| } | |
| /* Fill the remaining entries with unused physical lanes (ascending) */ | |
| for (i = cnt; i < DP_MAX_NUM_DP_LANES && j < DP_MAX_NUM_DP_LANES; j++) { | |
| if (!used[j]) | |
| map[i++] = j; | |
| } | |
| out: | |
| if (endpoint) | |
| of_node_put(endpoint); | |
| dev_dbg(dev, "data-lanes count %d <%d %d %d %d>\n", cnt, map[0], map[1], map[2], map[3]); | |
| memcpy(msm_dp_link->lane_map, map, sizeof(map)); | |
| return 0; | |
| } | |
| static int msm_dp_link_parse_dt(struct device *dev, struct msm_dp_link *msm_dp_link) | |
| { | |
| struct device_node *of_node = dev->of_node; | |
| int cnt; | |
| /* | |
| * data-lanes is the property of msm_dp_out endpoint | |
| */ | |
| cnt = drm_of_get_data_lanes_count_ep(of_node, 1, 0, 1, DP_MAX_NUM_DP_LANES); | |
| if (cnt < 0) { | |
| /* legacy code, data-lanes is the property of mdss_dp node */ | |
| cnt = drm_of_get_data_lanes_count(of_node, 1, DP_MAX_NUM_DP_LANES); | |
| } | |
| if (cnt > 0) | |
| msm_dp_link->max_dp_lanes = cnt; | |
| else | |
| msm_dp_link->max_dp_lanes = DP_MAX_NUM_DP_LANES; /* 4 lanes */ | |
| if (msm_dp_link_lane_map(dev, msm_dp_link)) { | |
| dev_err(dev, "failed to parse data-lanes\n"); | |
| return -EINVAL; | |
| } | |
| msm_dp_link->max_dp_link_rate = msm_dp_link_link_frequencies(of_node); | |
| if (!msm_dp_link->max_dp_link_rate) | |
| msm_dp_link->max_dp_link_rate = DP_LINK_RATE_HBR2; | |
| return 0; | |
| } | |
| struct msm_dp_link *msm_dp_link_get(struct device *dev, struct drm_dp_aux *aux) | |
| { | |
| struct msm_dp_link_private *link; | |
| struct msm_dp_link *msm_dp_link; | |
| int ret; | |
| if (!dev || !aux) { | |
| DRM_ERROR("invalid input\n"); | |
| return ERR_PTR(-EINVAL); | |
| } | |
| link = devm_kzalloc(dev, sizeof(*link), GFP_KERNEL); | |
| if (!link) | |
| return ERR_PTR(-ENOMEM); | |
| link->aux = aux; | |
| mutex_init(&link->psm_mutex); | |
| msm_dp_link = &link->msm_dp_link; | |
| ret = msm_dp_link_parse_dt(dev, msm_dp_link); | |
| if (ret) | |
| return ERR_PTR(ret); | |
| return msm_dp_link; | |
| } |