link->dpcd_sink_count = 0;
 }
 
-static void detect_dp(
+static bool detect_dp(
        struct dc_link *link,
        struct display_sink_capability *sink_caps,
        bool *converter_disable_audio,
 
        if (sink_caps->transaction_type == DDC_TRANSACTION_TYPE_I2C_OVER_AUX) {
                sink_caps->signal = SIGNAL_TYPE_DISPLAY_PORT;
-               detect_dp_sink_caps(link);
+               if (!detect_dp_sink_caps(link))
+                       return false;
 
                if (is_mst_supported(link)) {
                        sink_caps->signal = SIGNAL_TYPE_DISPLAY_PORT_MST;
                                 * active dongle unplug processing for short irq
                                 */
                                link_disconnect_sink(link);
-                               return;
+                               return true;
                        }
 
                        if (link->dpcd_caps.dongle_type != DISPLAY_DONGLE_DP_HDMI_CONVERTER)
                                sink_caps,
                                audio_support);
        }
+
+       return true;
 }
 
 bool dc_link_detect(struct dc_link *link, enum dc_detect_reason reason)
                }
 
                case SIGNAL_TYPE_DISPLAY_PORT: {
-                       detect_dp(
+                       if (!detect_dp(
                                link,
                                &sink_caps,
                                &converter_disable_audio,
-                               aud_support, reason);
+                               aud_support, reason))
+                               return false;
 
                        /* Active dongle downstream unplug */
                        if (link->type == dc_connection_active_dongle
 
                link->wa_flags.dp_keep_receiver_powered = false;
 }
 
-static void retrieve_link_cap(struct dc_link *link)
+static bool retrieve_link_cap(struct dc_link *link)
 {
        uint8_t dpcd_data[DP_TRAINING_AUX_RD_INTERVAL - DP_DPCD_REV + 1];
 
        union down_stream_port_count down_strm_port_count;
        union edp_configuration_cap edp_config_cap;
        union dp_downstream_port_present ds_port = { 0 };
+       enum dc_status status = DC_ERROR_UNEXPECTED;
 
        memset(dpcd_data, '\0', sizeof(dpcd_data));
        memset(&down_strm_port_count,
        memset(&edp_config_cap, '\0',
                sizeof(union edp_configuration_cap));
 
-       core_link_read_dpcd(
-               link,
-               DP_DPCD_REV,
-               dpcd_data,
-               sizeof(dpcd_data));
+       status = core_link_read_dpcd(
+                       link,
+                       DP_DPCD_REV,
+                       dpcd_data,
+                       sizeof(dpcd_data));
+
+       if (status != DC_OK) {
+               dm_error("%s: Read dpcd data failed.\n", __func__);
+               return false;
+       }
 
        {
                union training_aux_rd_interval aux_rd_interval;
 
        /* Connectivity log: detection */
        CONN_DATA_DETECT(link, dpcd_data, sizeof(dpcd_data), "Rx Caps: ");
+
+       return true;
 }
 
-void detect_dp_sink_caps(struct dc_link *link)
+bool detect_dp_sink_caps(struct dc_link *link)
 {
-       retrieve_link_cap(link);
+       return retrieve_link_cap(link);
 
        /* dc init_hw has power encoder using default
         * signal for connector. For native DP, no