drm/amd/display: replace all dc_link function call in link with link functions

[why]
Link components should not reply on dc_link_exports to access link function in
other link components.

Reviewed-by: Jun Lei <Jun.Lei@amd.com>
Acked-by: Qingqing Zhuo <qingqing.zhuo@amd.com>
Signed-off-by: Wenjing Liu <wenjing.liu@amd.com>
Tested-by: Daniel Wheeler <daniel.wheeler@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>

diff --git a/drivers/gpu/drm/amd/display/dc/dcn31/dcn31_dio_link_encoder.c b/drivers/gpu/drm/amd/display/dc/dcn31/dcn31_dio_link_encoder.c
index 275e78c..745a5d1 100644 (file)
--- a/drivers/gpu/drm/amd/display/dc/dcn31/dcn31_dio_link_encoder.c
+++ b/drivers/gpu/drm/amd/display/dc/dcn31/dcn31_dio_link_encoder.c
@@ -37,6 +37,7 @@
 #include "link_enc_cfg.h"
 #include "dc_dmub_srv.h"
 #include "dal_asic_id.h"
+#include "link.h"
 
 #define CTX \
        enc10->base.ctx
@@ -485,7 +486,7 @@ void dcn31_link_encoder_enable_dp_output(
 
                if (link) {
                        dpia_control.dpia_id = link->ddc_hw_inst;
-                       dpia_control.fec_rdy = dc_link_should_enable_fec(link);
+                       dpia_control.fec_rdy = link->dc->link_srv->dp_should_enable_fec(link);
                } else {
                        DC_LOG_ERROR("%s: Failed to execute DPIA enable DMUB command.\n", __func__);
                        BREAK_TO_DEBUGGER();
@@ -532,7 +533,7 @@ void dcn31_link_encoder_enable_dp_mst_output(
 
                if (link) {
                        dpia_control.dpia_id = link->ddc_hw_inst;
-                       dpia_control.fec_rdy = dc_link_should_enable_fec(link);
+                       dpia_control.fec_rdy = link->dc->link_srv->dp_should_enable_fec(link);
                } else {
                        DC_LOG_ERROR("%s: Failed to execute DPIA enable DMUB command.\n", __func__);
                        BREAK_TO_DEBUGGER();

diff --git a/drivers/gpu/drm/amd/display/dc/link/accessories/link_dp_cts.c b/drivers/gpu/drm/amd/display/dc/link/accessories/link_dp_cts.c
index 080019f..704373d 100644 (file)
--- a/drivers/gpu/drm/amd/display/dc/link/accessories/link_dp_cts.c
+++ b/drivers/gpu/drm/amd/display/dc/link/accessories/link_dp_cts.c
@@ -250,7 +250,7 @@ static void dp_test_send_phy_test_pattern(struct dc_link *link)
        /* prepare link training settings */
        link_training_settings.link_settings = link->cur_link_settings;
 
-       link_training_settings.lttpr_mode = dc_link_decide_lttpr_mode(link, &link->cur_link_settings);
+       link_training_settings.lttpr_mode = dp_decide_lttpr_mode(link, &link->cur_link_settings);
 
        if ((link->chip_caps & EXT_DISPLAY_PATH_CAPS__DP_FIXED_VS_EN) &&
                        link_training_settings.lttpr_mode == LTTPR_MODE_TRANSPARENT)
@@ -408,7 +408,7 @@ static void dp_test_send_phy_test_pattern(struct dc_link *link)
         * all the time. Do not touch it.
         * forward request to DS
         */
-       dc_link_dp_set_test_pattern(
+       dp_set_test_pattern(
                link,
                test_pattern,
                DP_TEST_PATTERN_COLOR_SPACE_UNDEFINED,
@@ -1006,5 +1006,5 @@ void dp_set_preferred_training_settings(struct dc *dc,
 
        /* Retrain now, or wait until next stream update to apply */
        if (skip_immediate_retrain == false)
-               dc_link_set_preferred_link_settings(dc, &link->preferred_link_setting, link);
+               dp_set_preferred_link_settings(dc, &link->preferred_link_setting, link);
 }

diff --git a/drivers/gpu/drm/amd/display/dc/link/link_dpms.c b/drivers/gpu/drm/amd/display/dc/link/link_dpms.c
index 650ac2a..00d441c 100644 (file)
--- a/drivers/gpu/drm/amd/display/dc/link/link_dpms.c
+++ b/drivers/gpu/drm/amd/display/dc/link/link_dpms.c
@@ -137,7 +137,7 @@ void link_blank_dp_stream(struct dc_link *link, bool hw_init)
                }
 
                if ((!link->wa_flags.dp_keep_receiver_powered) || hw_init)
-                       dc_link_dp_receiver_power_ctrl(link, false);
+                       dpcd_write_rx_power_ctrl(link, false);
        }
 }
 

diff --git a/drivers/gpu/drm/amd/display/dc/link/link_validation.c b/drivers/gpu/drm/amd/display/dc/link/link_validation.c
index d4f6ee6..b29f623 100644 (file)
--- a/drivers/gpu/drm/amd/display/dc/link/link_validation.c
+++ b/drivers/gpu/drm/amd/display/dc/link/link_validation.c
@@ -29,6 +29,7 @@
  * provides helper functions exposing bandwidth formulas used in validation.
  */
 #include "link_validation.h"
+#include "protocols/link_dp_capability.h"
 #include "resource.h"
 
 #define DC_LOGGER_INIT(logger)
@@ -233,7 +234,7 @@ uint32_t dp_link_bandwidth_kbps(
                 */
                link_rate_per_lane_kbps = link_settings->link_rate * LINK_RATE_REF_FREQ_IN_KHZ * BITS_PER_DP_BYTE;
                total_data_bw_efficiency_x10000 = DATA_EFFICIENCY_8b_10b_x10000;
-               if (dc_link_should_enable_fec(link)) {
+               if (dp_should_enable_fec(link)) {
                        total_data_bw_efficiency_x10000 /= 100;
                        total_data_bw_efficiency_x10000 *= DATA_EFFICIENCY_8b_10b_FEC_EFFICIENCY_x100;
                }
@@ -329,7 +330,7 @@ static bool dp_validate_mode_timing(
                timing->v_addressable == (uint32_t) 480)
                return true;
 
-       link_setting = dc_link_get_link_cap(link);
+       link_setting = dp_get_verified_link_cap(link);
 
        /* TODO: DYNAMIC_VALIDATION needs to be implemented */
        /*if (flags.DYNAMIC_VALIDATION == 1 &&

diff --git a/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_capability.c b/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_capability.c
index 97856c4..75e1a68 100644 (file)
--- a/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_capability.c
+++ b/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_capability.c
@@ -42,6 +42,8 @@
 #include "link_edp_panel_control.h"
 #include "link_dp_irq_handler.h"
 #include "link/accessories/link_dp_trace.h"
+#include "link/link_detection.h"
+#include "link/link_validation.h"
 #include "link_dp_training.h"
 #include "atomfirmware.h"
 #include "resource.h"
@@ -278,7 +280,7 @@ static void dp_wa_power_up_0010FA(struct dc_link *link, uint8_t *dpcd_data,
 
        if (!link->dpcd_caps.dpcd_rev.raw) {
                do {
-                       dc_link_dp_receiver_power_ctrl(link, true);
+                       dpcd_write_rx_power_ctrl(link, true);
                        core_link_read_dpcd(link, DP_DPCD_REV,
                                                        dpcd_data, length);
                        link->dpcd_caps.dpcd_rev.raw = dpcd_data[
@@ -342,7 +344,7 @@ bool dp_should_enable_fec(const struct dc_link *link)
                                || !link->dc->caps.edp_dsc_support))
                force_disable = true;
 
-       return !force_disable && dc_link_is_fec_supported(link);
+       return !force_disable && dp_is_fec_supported(link);
 }
 
 bool link_is_dp_128b_132b_signal(struct pipe_ctx *pipe_ctx)
@@ -645,7 +647,7 @@ static bool decide_dp_link_settings(struct dc_link *link, struct dc_link_setting
                        initial_link_setting;
        uint32_t link_bw;
 
-       if (req_bw > dc_link_bandwidth_kbps(link, &link->verified_link_cap))
+       if (req_bw > dp_link_bandwidth_kbps(link, &link->verified_link_cap))
                return false;
 
        /* search for the minimum link setting that:
@@ -765,7 +767,7 @@ bool decide_edp_link_settings_with_dsc(struct dc_link *link,
                initial_link_setting.use_link_rate_set = false;
                initial_link_setting.link_rate_set = 0;
                current_link_setting = initial_link_setting;
-               if (req_bw > dc_link_bandwidth_kbps(link, &link->verified_link_cap))
+               if (req_bw > dp_link_bandwidth_kbps(link, &link->verified_link_cap))
                        return false;
 
                /* search for the minimum link setting that:
@@ -774,7 +776,7 @@ bool decide_edp_link_settings_with_dsc(struct dc_link *link,
                 */
                while (current_link_setting.link_rate <=
                                max_link_rate) {
-                       link_bw = dc_link_bandwidth_kbps(
+                       link_bw = dp_link_bandwidth_kbps(
                                        link,
                                        &current_link_setting);
                        if (req_bw <= link_bw) {
@@ -831,7 +833,7 @@ bool decide_edp_link_settings_with_dsc(struct dc_link *link,
         */
        while (current_link_setting.link_rate <=
                        max_link_rate) {
-               link_bw = dc_link_bandwidth_kbps(
+               link_bw = dp_link_bandwidth_kbps(
                                link,
                                &current_link_setting);
                if (req_bw <= link_bw) {
@@ -889,7 +891,7 @@ bool link_decide_link_settings(struct dc_stream_state *stream,
        struct dc_link_settings *link_setting)
 {
        struct dc_link *link = stream->link;
-       uint32_t req_bw = dc_bandwidth_in_kbps_from_timing(&stream->timing);
+       uint32_t req_bw = link_timing_bandwidth_kbps(&stream->timing);
 
        memset(link_setting, 0, sizeof(*link_setting));
 
@@ -922,13 +924,13 @@ bool link_decide_link_settings(struct dc_stream_state *stream,
 
                                tmp_link_setting.link_rate = LINK_RATE_UNKNOWN;
                                tmp_timing.flags.DSC = 0;
-                               orig_req_bw = dc_bandwidth_in_kbps_from_timing(&tmp_timing);
-                               dc_link_decide_edp_link_settings(link, &tmp_link_setting, orig_req_bw);
+                               orig_req_bw = link_timing_bandwidth_kbps(&tmp_timing);
+                               edp_decide_link_settings(link, &tmp_link_setting, orig_req_bw);
                                max_link_rate = tmp_link_setting.link_rate;
                        }
                        decide_edp_link_settings_with_dsc(link, link_setting, req_bw, max_link_rate);
                } else {
-                       dc_link_decide_edp_link_settings(link, link_setting, req_bw);
+                       edp_decide_link_settings(link, link_setting, req_bw);
                }
        } else {
                decide_dp_link_settings(link, link_setting, req_bw);
@@ -2117,8 +2119,8 @@ static bool dp_verify_link_cap(
                if (status == LINK_TRAINING_SUCCESS) {
                        success = true;
                        fsleep(1000);
-                       if (dc_link_dp_read_hpd_rx_irq_data(link, &irq_data) == DC_OK &&
-                                       dc_link_check_link_loss_status(
+                       if (dp_read_hpd_rx_irq_data(link, &irq_data) == DC_OK &&
+                                       dp_parse_link_loss_status(
                                                        link,
                                                        &irq_data))
                                (*fail_count)++;
@@ -2158,7 +2160,7 @@ bool dp_verify_link_cap_with_retries(
 
                memset(&link->verified_link_cap, 0,
                                sizeof(struct dc_link_settings));
-               if (!dc_link_detect_connection_type(link, &type) || type == dc_connection_none) {
+               if (!link_detect_connection_type(link, &type) || type == dc_connection_none) {
                        link->verified_link_cap = fail_safe_link_settings;
                        break;
                } else if (dp_verify_link_cap(link, known_limit_link_setting,

diff --git a/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_irq_handler.c b/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_irq_handler.c
index 6611d07..ba95fac 100644 (file)
--- a/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_irq_handler.c
+++ b/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_irq_handler.c
@@ -33,6 +33,7 @@
 #include "link_dpcd.h"
 #include "link_dp_training.h"
 #include "link_dp_capability.h"
+#include "link_edp_panel_control.h"
 #include "link/accessories/link_dp_trace.h"
 #include "link/link_dpms.h"
 #include "dm_helpers.h"
@@ -155,9 +156,9 @@ static bool handle_hpd_irq_psr_sink(struct dc_link *link)
                        /* PSR error, disable and re-enable PSR */
                        if (link->psr_settings.psr_allow_active) {
                                allow_active = false;
-                               dc_link_set_psr_allow_active(link, &allow_active, true, false, NULL);
+                               edp_set_psr_allow_active(link, &allow_active, true, false, NULL);
                                allow_active = true;
-                               dc_link_set_psr_allow_active(link, &allow_active, true, false, NULL);
+                               edp_set_psr_allow_active(link, &allow_active, true, false, NULL);
                        }
 
                        return true;
@@ -289,7 +290,7 @@ bool dp_handle_hpd_rx_irq(struct dc_link *link,
                 * dal_dpsst_ls_read_hpd_irq_data
                 * Order of calls is important too
                 */
-       result = dc_link_dp_read_hpd_rx_irq_data(link, &hpd_irq_dpcd_data);
+       result = dp_read_hpd_rx_irq_data(link, &hpd_irq_dpcd_data);
        if (out_hpd_irq_dpcd_data)
                *out_hpd_irq_dpcd_data = hpd_irq_dpcd_data;
 
@@ -316,7 +317,7 @@ bool dp_handle_hpd_rx_irq(struct dc_link *link,
                return false;
        }
 
-       if (!dc_link_dp_allow_hpd_rx_irq(link)) {
+       if (!dp_should_allow_hpd_rx_irq(link)) {
                DC_LOG_HW_HPD_IRQ("%s: skipping HPD handling on %d\n",
                        __func__, link->link_index);
                return false;
@@ -349,9 +350,9 @@ bool dp_handle_hpd_rx_irq(struct dc_link *link,
         * then DM should call DC to do the detection.
         * NOTE: Do not handle link loss on eDP since it is internal link*/
        if ((link->connector_signal != SIGNAL_TYPE_EDP) &&
-               dc_link_check_link_loss_status(
-                       link,
-                       &hpd_irq_dpcd_data)) {
+                       dp_parse_link_loss_status(
+                                       link,
+                                       &hpd_irq_dpcd_data)) {
                /* Connectivity log: link loss */
                CONN_DATA_LINK_LOSS(link,
                                        hpd_irq_dpcd_data.raw,
@@ -361,7 +362,7 @@ bool dp_handle_hpd_rx_irq(struct dc_link *link,
                if (defer_handling && has_left_work)
                        *has_left_work = true;
                else
-                       dc_link_dp_handle_link_loss(link);
+                       dp_handle_link_loss(link);
 
                status = false;
                if (out_link_loss)

diff --git a/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_phy.c b/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_phy.c
index 92c2aa1..b7abba5 100644 (file)
--- a/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_phy.c
+++ b/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_phy.c
@@ -64,7 +64,7 @@ void dp_enable_link_phy(
        link->cur_link_settings = *link_settings;
        link->dc->hwss.enable_dp_link_output(link, link_res, signal,
                        clock_source, link_settings);
-       dc_link_dp_receiver_power_ctrl(link, true);
+       dpcd_write_rx_power_ctrl(link, true);
 }
 
 void dp_disable_link_phy(struct dc_link *link,
@@ -74,7 +74,7 @@ void dp_disable_link_phy(struct dc_link *link,
        struct dc  *dc = link->ctx->dc;
 
        if (!link->wa_flags.dp_keep_receiver_powered)
-               dc_link_dp_receiver_power_ctrl(link, false);
+               dpcd_write_rx_power_ctrl(link, false);
 
        dc->hwss.disable_link_output(link, link_res, signal);
        /* Clear current link setting.*/
@@ -143,7 +143,7 @@ enum dc_status dp_set_fec_ready(struct dc_link *link, const struct link_resource
        link_enc = link_enc_cfg_get_link_enc(link);
        ASSERT(link_enc);
 
-       if (!dc_link_should_enable_fec(link))
+       if (!dp_should_enable_fec(link))
                return status;
 
        if (link_enc->funcs->fec_set_ready &&
@@ -183,7 +183,7 @@ void dp_set_fec_enable(struct dc_link *link, bool enable)
        link_enc = link_enc_cfg_get_link_enc(link);
        ASSERT(link_enc);
 
-       if (!dc_link_should_enable_fec(link))
+       if (!dp_should_enable_fec(link))
                return;
 
        if (link_enc->funcs->fec_set_enable &&

diff --git a/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_training.c b/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_training.c
index 2948319..4a3758e 100644 (file)
--- a/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_training.c
+++ b/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_training.c
@@ -41,6 +41,7 @@
 #include "link_dp_phy.h"
 #include "link_dp_capability.h"
 #include "link_edp_panel_control.h"
+#include "link/link_detection.h"
 #include "atomfirmware.h"
 #include "link_enc_cfg.h"
 #include "resource.h"
@@ -1644,7 +1645,7 @@ bool perform_link_training_with_retries(
                if (status == LINK_TRAINING_ABORT) {
                        enum dc_connection_type type = dc_connection_none;
 
-                       dc_link_detect_connection_type(link, &type);
+                       link_detect_connection_type(link, &type);
                        if (type == dc_connection_none) {
                                DC_LOG_HW_LINK_TRAINING("%s: Aborting training because sink unplugged\n", __func__);
                                break;
@@ -1676,8 +1677,8 @@ bool perform_link_training_with_retries(
                        /* Flag if reduced link bandwidth no longer meets stream requirements or fallen back to
                         * minimum link bandwidth.
                         */
-                       req_bw = dc_bandwidth_in_kbps_from_timing(&stream->timing);
-                       link_bw = dc_link_bandwidth_kbps(link, &cur_link_settings);
+                       req_bw = link_timing_bandwidth_kbps(&stream->timing);
+                       link_bw = dp_link_bandwidth_kbps(link, &cur_link_settings);
                        is_link_bw_low = (req_bw > link_bw);
                        is_link_bw_min = ((cur_link_settings.link_rate <= LINK_RATE_LOW) &&
                                (cur_link_settings.lane_count <= LANE_COUNT_ONE));

diff --git a/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_training_dpia.c b/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_training_dpia.c
index 0f56db4..ab4aafd 100644 (file)
--- a/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_training_dpia.c
+++ b/drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_training_dpia.c
@@ -998,7 +998,7 @@ enum link_training_result dpia_perform_link_training(
 
        struct dc_link_settings link_settings = *link_setting; // non-const copy to pass in
 
-       lt_settings.lttpr_mode = dc_link_decide_lttpr_mode(link, &link_settings);
+       lt_settings.lttpr_mode = dp_decide_lttpr_mode(link, &link_settings);
 
        /* Configure link as prescribed in link_setting and set LTTPR mode. */
        result = dpia_configure_link(link, link_res, link_setting, &lt_settings);

diff --git a/drivers/gpu/drm/amd/display/dc/link/protocols/link_edp_panel_control.c b/drivers/gpu/drm/amd/display/dc/link/protocols/link_edp_panel_control.c
index 2f7e0f4..eaafa00 100644 (file)
--- a/drivers/gpu/drm/amd/display/dc/link/protocols/link_edp_panel_control.c
+++ b/drivers/gpu/drm/amd/display/dc/link/protocols/link_edp_panel_control.c
@@ -243,7 +243,7 @@ bool set_default_brightness_aux(struct dc_link *link)
                if (default_backlight < 5000 || default_backlight > 5000000)
                        default_backlight = 150000; //
 
-               return dc_link_set_backlight_level_nits(link, true,
+               return edp_set_backlight_level_nits(link, true,
                                default_backlight, 0);
        }
        return false;
@@ -282,10 +282,10 @@ bool link_is_edp_ilr_optimization_required(struct dc_link *link,
        core_link_read_dpcd(link, DP_LANE_COUNT_SET,
                                &lane_count_set.raw, sizeof(lane_count_set));
 
-       req_bw = dc_bandwidth_in_kbps_from_timing(crtc_timing);
+       req_bw = link_timing_bandwidth_kbps(crtc_timing);
 
        if (!crtc_timing->flags.DSC)
-               dc_link_decide_edp_link_settings(link, &link_setting, req_bw);
+               edp_decide_link_settings(link, &link_setting, req_bw);
        else
                decide_edp_link_settings_with_dsc(link, &link_setting, req_bw, LINK_RATE_UNKNOWN);