1 /* 2 * Copyright 2022 Advanced Micro Devices, Inc. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included in 12 * all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 * 22 * Authors: AMD 23 * 24 */ 25 26 /* FILE POLICY AND INTENDED USAGE: 27 * This file implements basic dp phy functionality such as enable/disable phy 28 * output and set lane/drive settings. This file is responsible for maintaining 29 * and update software state representing current phy status such as current 30 * link settings. 31 */ 32 33 #include "link_dp_phy.h" 34 #include "link_dpcd.h" 35 #include "link_dp_training.h" 36 #include "link_dp_capability.h" 37 #include "clk_mgr.h" 38 #include "resource.h" 39 #include "link_enc_cfg.h" 40 #define DC_LOGGER \ 41 link->ctx->logger 42 43 void dpcd_write_rx_power_ctrl(struct dc_link *link, bool on) 44 { 45 uint8_t state; 46 47 state = on ? DP_POWER_STATE_D0 : DP_POWER_STATE_D3; 48 49 if (link->sync_lt_in_progress) 50 return; 51 52 core_link_write_dpcd(link, DP_SET_POWER, &state, 53 sizeof(state)); 54 55 } 56 57 void dp_enable_link_phy( 58 struct dc_link *link, 59 const struct link_resource *link_res, 60 enum signal_type signal, 61 enum clock_source_id clock_source, 62 const struct dc_link_settings *link_settings) 63 { 64 link->cur_link_settings = *link_settings; 65 link->dc->hwss.enable_dp_link_output(link, link_res, signal, 66 clock_source, link_settings); 67 dpcd_write_rx_power_ctrl(link, true); 68 } 69 70 void dp_disable_link_phy(struct dc_link *link, 71 const struct link_resource *link_res, 72 enum signal_type signal) 73 { 74 struct dc *dc = link->ctx->dc; 75 76 if (!link->wa_flags.dp_keep_receiver_powered) 77 dpcd_write_rx_power_ctrl(link, false); 78 79 dc->hwss.disable_link_output(link, link_res, signal); 80 /* Clear current link setting.*/ 81 memset(&link->cur_link_settings, 0, 82 sizeof(link->cur_link_settings)); 83 84 if (dc->clk_mgr->funcs->notify_link_rate_change) 85 dc->clk_mgr->funcs->notify_link_rate_change(dc->clk_mgr, link); 86 } 87 88 static inline bool is_immediate_downstream(struct dc_link *link, uint32_t offset) 89 { 90 return (dp_parse_lttpr_repeater_count(link->dpcd_caps.lttpr_caps.phy_repeater_cnt) == 91 offset); 92 } 93 94 void dp_set_hw_lane_settings( 95 struct dc_link *link, 96 const struct link_resource *link_res, 97 const struct link_training_settings *link_settings, 98 uint32_t offset) 99 { 100 const struct link_hwss *link_hwss = get_link_hwss(link, link_res); 101 102 if ((link_settings->lttpr_mode == LTTPR_MODE_NON_TRANSPARENT) && 103 !is_immediate_downstream(link, offset)) 104 return; 105 106 if (link_hwss->ext.set_dp_lane_settings) 107 link_hwss->ext.set_dp_lane_settings(link, link_res, 108 &link_settings->link_settings, 109 link_settings->hw_lane_settings); 110 111 memmove(link->cur_lane_setting, 112 link_settings->hw_lane_settings, 113 sizeof(link->cur_lane_setting)); 114 } 115 116 void dp_set_drive_settings( 117 struct dc_link *link, 118 const struct link_resource *link_res, 119 struct link_training_settings *lt_settings) 120 { 121 /* program ASIC PHY settings*/ 122 dp_set_hw_lane_settings(link, link_res, lt_settings, DPRX); 123 124 dp_hw_to_dpcd_lane_settings(lt_settings, 125 lt_settings->hw_lane_settings, 126 lt_settings->dpcd_lane_settings); 127 128 /* Notify DP sink the PHY settings from source */ 129 dpcd_set_lane_settings(link, lt_settings, DPRX); 130 } 131 132 enum dc_status dp_set_fec_ready(struct dc_link *link, const struct link_resource *link_res, bool ready) 133 { 134 /* FEC has to be "set ready" before the link training. 135 * The policy is to always train with FEC 136 * if the sink supports it and leave it enabled on link. 137 * If FEC is not supported, disable it. 138 */ 139 struct link_encoder *link_enc = NULL; 140 enum dc_status status = DC_OK; 141 uint8_t fec_config = 0; 142 143 link_enc = link_enc_cfg_get_link_enc(link); 144 ASSERT(link_enc); 145 146 if (!dp_should_enable_fec(link)) 147 return status; 148 149 if (link_enc->funcs->fec_set_ready && 150 link->dpcd_caps.fec_cap.bits.FEC_CAPABLE) { 151 if (ready) { 152 fec_config = 1; 153 status = core_link_write_dpcd(link, 154 DP_FEC_CONFIGURATION, 155 &fec_config, 156 sizeof(fec_config)); 157 if (status == DC_OK) { 158 link_enc->funcs->fec_set_ready(link_enc, true); 159 link->fec_state = dc_link_fec_ready; 160 } else { 161 link_enc->funcs->fec_set_ready(link_enc, false); 162 link->fec_state = dc_link_fec_not_ready; 163 dm_error("dpcd write failed to set fec_ready"); 164 } 165 } else if (link->fec_state == dc_link_fec_ready) { 166 fec_config = 0; 167 status = core_link_write_dpcd(link, 168 DP_FEC_CONFIGURATION, 169 &fec_config, 170 sizeof(fec_config)); 171 link_enc->funcs->fec_set_ready(link_enc, false); 172 link->fec_state = dc_link_fec_not_ready; 173 } 174 } 175 176 return status; 177 } 178 179 void dp_set_fec_enable(struct dc_link *link, bool enable) 180 { 181 struct link_encoder *link_enc = NULL; 182 183 link_enc = link_enc_cfg_get_link_enc(link); 184 ASSERT(link_enc); 185 186 if (!dp_should_enable_fec(link)) 187 return; 188 189 if (link_enc->funcs->fec_set_enable && 190 link->dpcd_caps.fec_cap.bits.FEC_CAPABLE) { 191 if (link->fec_state == dc_link_fec_ready && enable) { 192 /* Accord to DP spec, FEC enable sequence can first 193 * be transmitted anytime after 1000 LL codes have 194 * been transmitted on the link after link training 195 * completion. Using 1 lane RBR should have the maximum 196 * time for transmitting 1000 LL codes which is 6.173 us. 197 * So use 7 microseconds delay instead. 198 */ 199 udelay(7); 200 link_enc->funcs->fec_set_enable(link_enc, true); 201 link->fec_state = dc_link_fec_enabled; 202 } else if (link->fec_state == dc_link_fec_enabled && !enable) { 203 link_enc->funcs->fec_set_enable(link_enc, false); 204 link->fec_state = dc_link_fec_ready; 205 } 206 } 207 } 208 209