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 #include "link_hwss_dio.h"
26 #include "core_types.h"
27 #include "link_enc_cfg.h"
28
29 /**
30 * DOC: overview
31 *
32 * Display Input Output (DIO), is the display input and output unit in DCN. It
33 * includes output encoders to support different display output, like
34 * DisplayPort, HDMI, DVI interface, and others. It also includes the control
35 * and status channels for these interfaces.
36 */
37
38
set_dio_throttled_vcp_size(struct pipe_ctx * pipe_ctx,struct fixed31_32 throttled_vcp_size)39 void set_dio_throttled_vcp_size(struct pipe_ctx *pipe_ctx,
40 struct fixed31_32 throttled_vcp_size)
41 {
42 struct stream_encoder *stream_encoder = pipe_ctx->stream_res.stream_enc;
43
44 stream_encoder->funcs->set_throttled_vcp_size(
45 stream_encoder,
46 throttled_vcp_size);
47 }
48
setup_dio_stream_encoder(struct pipe_ctx * pipe_ctx)49 void setup_dio_stream_encoder(struct pipe_ctx *pipe_ctx)
50 {
51 struct link_encoder *link_enc = link_enc_cfg_get_link_enc(pipe_ctx->stream->link);
52 struct stream_encoder *stream_enc = pipe_ctx->stream_res.stream_enc;
53
54 link_enc->funcs->connect_dig_be_to_fe(link_enc,
55 pipe_ctx->stream_res.stream_enc->id, true);
56 if (dc_is_dp_signal(pipe_ctx->stream->signal))
57 pipe_ctx->stream->ctx->dc->link_srv->dp_trace_source_sequence(pipe_ctx->stream->link,
58 DPCD_SOURCE_SEQ_AFTER_CONNECT_DIG_FE_BE);
59 if (stream_enc->funcs->enable_stream)
60 stream_enc->funcs->enable_stream(stream_enc,
61 pipe_ctx->stream->signal, true);
62 if (stream_enc->funcs->map_stream_to_link)
63 stream_enc->funcs->map_stream_to_link(stream_enc,
64 stream_enc->stream_enc_inst, link_enc->transmitter - TRANSMITTER_UNIPHY_A);
65 if (stream_enc->funcs->set_input_mode)
66 stream_enc->funcs->set_input_mode(stream_enc,
67 pipe_ctx->stream_res.pix_clk_params.dio_se_pix_per_cycle);
68 if (stream_enc->funcs->enable_fifo)
69 stream_enc->funcs->enable_fifo(stream_enc);
70 }
71
reset_dio_stream_encoder(struct pipe_ctx * pipe_ctx)72 void reset_dio_stream_encoder(struct pipe_ctx *pipe_ctx)
73 {
74 struct link_encoder *link_enc = link_enc_cfg_get_link_enc(pipe_ctx->stream->link);
75 struct stream_encoder *stream_enc = pipe_ctx->stream_res.stream_enc;
76
77 if (!stream_enc)
78 return;
79
80 if (stream_enc->funcs->disable_fifo)
81 stream_enc->funcs->disable_fifo(stream_enc);
82 if (stream_enc->funcs->set_input_mode)
83 stream_enc->funcs->set_input_mode(stream_enc, 0);
84 if (stream_enc->funcs->enable_stream)
85 stream_enc->funcs->enable_stream(stream_enc,
86 pipe_ctx->stream->signal, false);
87 link_enc->funcs->connect_dig_be_to_fe(
88 link_enc,
89 pipe_ctx->stream_res.stream_enc->id,
90 false);
91 if (dc_is_dp_signal(pipe_ctx->stream->signal))
92 pipe_ctx->stream->ctx->dc->link_srv->dp_trace_source_sequence(
93 pipe_ctx->stream->link,
94 DPCD_SOURCE_SEQ_AFTER_DISCONNECT_DIG_FE_BE);
95
96 }
97
setup_dio_stream_attribute(struct pipe_ctx * pipe_ctx)98 void setup_dio_stream_attribute(struct pipe_ctx *pipe_ctx)
99 {
100 struct stream_encoder *stream_encoder = pipe_ctx->stream_res.stream_enc;
101 struct dc_stream_state *stream = pipe_ctx->stream;
102 struct dc_link *link = stream->link;
103
104 if (!dc_is_virtual_signal(stream->signal))
105 stream_encoder->funcs->setup_stereo_sync(
106 stream_encoder,
107 pipe_ctx->stream_res.tg->inst,
108 stream->timing.timing_3d_format != TIMING_3D_FORMAT_NONE);
109
110 if (dc_is_dp_signal(stream->signal))
111 stream_encoder->funcs->dp_set_stream_attribute(
112 stream_encoder,
113 &stream->timing,
114 stream->output_color_space,
115 stream->use_vsc_sdp_for_colorimetry,
116 link->dpcd_caps.dprx_feature.bits.SST_SPLIT_SDP_CAP);
117 else if (dc_is_hdmi_tmds_signal(stream->signal))
118 stream_encoder->funcs->hdmi_set_stream_attribute(
119 stream_encoder,
120 &stream->timing,
121 stream->phy_pix_clk,
122 pipe_ctx->stream_res.audio != NULL);
123 else if (dc_is_dvi_signal(stream->signal))
124 stream_encoder->funcs->dvi_set_stream_attribute(
125 stream_encoder,
126 &stream->timing,
127 (stream->signal == SIGNAL_TYPE_DVI_DUAL_LINK) ?
128 true : false);
129 else if (dc_is_lvds_signal(stream->signal))
130 stream_encoder->funcs->lvds_set_stream_attribute(
131 stream_encoder,
132 &stream->timing);
133
134 if (dc_is_dp_signal(stream->signal))
135 link->dc->link_srv->dp_trace_source_sequence(link,
136 DPCD_SOURCE_SEQ_AFTER_DP_STREAM_ATTR);
137 }
138
enable_dio_dp_link_output(struct dc_link * link,const struct link_resource * link_res,enum signal_type signal,enum clock_source_id clock_source,const struct dc_link_settings * link_settings)139 void enable_dio_dp_link_output(struct dc_link *link,
140 const struct link_resource *link_res,
141 enum signal_type signal,
142 enum clock_source_id clock_source,
143 const struct dc_link_settings *link_settings)
144 {
145 struct link_encoder *link_enc = link_enc_cfg_get_link_enc(link);
146
147 if (dc_is_dp_sst_signal(signal))
148 link_enc->funcs->enable_dp_output(
149 link_enc,
150 link_settings,
151 clock_source);
152 else
153 link_enc->funcs->enable_dp_mst_output(
154 link_enc,
155 link_settings,
156 clock_source);
157 link->dc->link_srv->dp_trace_source_sequence(link,
158 DPCD_SOURCE_SEQ_AFTER_ENABLE_LINK_PHY);
159 }
160
disable_dio_link_output(struct dc_link * link,const struct link_resource * link_res,enum signal_type signal)161 void disable_dio_link_output(struct dc_link *link,
162 const struct link_resource *link_res,
163 enum signal_type signal)
164 {
165 struct link_encoder *link_enc = link_enc_cfg_get_link_enc(link);
166
167 link_enc->funcs->disable_output(link_enc, signal);
168 link->dc->link_srv->dp_trace_source_sequence(link,
169 DPCD_SOURCE_SEQ_AFTER_DISABLE_LINK_PHY);
170 }
171
set_dio_dp_link_test_pattern(struct dc_link * link,const struct link_resource * link_res,struct encoder_set_dp_phy_pattern_param * tp_params)172 void set_dio_dp_link_test_pattern(struct dc_link *link,
173 const struct link_resource *link_res,
174 struct encoder_set_dp_phy_pattern_param *tp_params)
175 {
176 struct link_encoder *link_enc = link_enc_cfg_get_link_enc(link);
177
178 link_enc->funcs->dp_set_phy_pattern(link_enc, tp_params);
179 link->dc->link_srv->dp_trace_source_sequence(link, DPCD_SOURCE_SEQ_AFTER_SET_SOURCE_PATTERN);
180 }
181
set_dio_dp_lane_settings(struct dc_link * link,const struct link_resource * link_res,const struct dc_link_settings * link_settings,const struct dc_lane_settings lane_settings[LANE_COUNT_DP_MAX])182 void set_dio_dp_lane_settings(struct dc_link *link,
183 const struct link_resource *link_res,
184 const struct dc_link_settings *link_settings,
185 const struct dc_lane_settings lane_settings[LANE_COUNT_DP_MAX])
186 {
187 struct link_encoder *link_enc = link_enc_cfg_get_link_enc(link);
188
189 link_enc->funcs->dp_set_lane_settings(link_enc, link_settings, lane_settings);
190 }
191
update_dio_stream_allocation_table(struct dc_link * link,const struct link_resource * link_res,const struct link_mst_stream_allocation_table * table)192 void update_dio_stream_allocation_table(struct dc_link *link,
193 const struct link_resource *link_res,
194 const struct link_mst_stream_allocation_table *table)
195 {
196 struct link_encoder *link_enc = link_enc_cfg_get_link_enc(link);
197
198 ASSERT(link_enc);
199 link_enc->funcs->update_mst_stream_allocation_table(link_enc, table);
200 }
201
setup_dio_audio_output(struct pipe_ctx * pipe_ctx,struct audio_output * audio_output,uint32_t audio_inst)202 void setup_dio_audio_output(struct pipe_ctx *pipe_ctx,
203 struct audio_output *audio_output, uint32_t audio_inst)
204 {
205 if (dc_is_dp_signal(pipe_ctx->stream->signal))
206 pipe_ctx->stream_res.stream_enc->funcs->dp_audio_setup(
207 pipe_ctx->stream_res.stream_enc,
208 audio_inst,
209 &pipe_ctx->stream->audio_info);
210 else
211 pipe_ctx->stream_res.stream_enc->funcs->hdmi_audio_setup(
212 pipe_ctx->stream_res.stream_enc,
213 audio_inst,
214 &pipe_ctx->stream->audio_info,
215 &audio_output->crtc_info);
216 }
217
enable_dio_audio_packet(struct pipe_ctx * pipe_ctx)218 void enable_dio_audio_packet(struct pipe_ctx *pipe_ctx)
219 {
220 if (dc_is_dp_signal(pipe_ctx->stream->signal))
221 pipe_ctx->stream_res.stream_enc->funcs->dp_audio_enable(
222 pipe_ctx->stream_res.stream_enc);
223
224 pipe_ctx->stream_res.stream_enc->funcs->audio_mute_control(
225 pipe_ctx->stream_res.stream_enc, false);
226
227 if (dc_is_dp_signal(pipe_ctx->stream->signal))
228 pipe_ctx->stream->ctx->dc->link_srv->dp_trace_source_sequence(
229 pipe_ctx->stream->link,
230 DPCD_SOURCE_SEQ_AFTER_ENABLE_AUDIO_STREAM);
231 }
232
disable_dio_audio_packet(struct pipe_ctx * pipe_ctx)233 void disable_dio_audio_packet(struct pipe_ctx *pipe_ctx)
234 {
235 pipe_ctx->stream_res.stream_enc->funcs->audio_mute_control(
236 pipe_ctx->stream_res.stream_enc, true);
237
238 if (pipe_ctx->stream_res.audio) {
239 if (dc_is_dp_signal(pipe_ctx->stream->signal))
240 pipe_ctx->stream_res.stream_enc->funcs->dp_audio_disable(
241 pipe_ctx->stream_res.stream_enc);
242 else
243 pipe_ctx->stream_res.stream_enc->funcs->hdmi_audio_disable(
244 pipe_ctx->stream_res.stream_enc);
245 }
246
247 if (dc_is_dp_signal(pipe_ctx->stream->signal))
248 pipe_ctx->stream->ctx->dc->link_srv->dp_trace_source_sequence(
249 pipe_ctx->stream->link,
250 DPCD_SOURCE_SEQ_AFTER_DISABLE_AUDIO_STREAM);
251 }
252
253 static const struct link_hwss dio_link_hwss = {
254 .setup_stream_encoder = setup_dio_stream_encoder,
255 .reset_stream_encoder = reset_dio_stream_encoder,
256 .setup_stream_attribute = setup_dio_stream_attribute,
257 .disable_link_output = disable_dio_link_output,
258 .setup_audio_output = setup_dio_audio_output,
259 .enable_audio_packet = enable_dio_audio_packet,
260 .disable_audio_packet = disable_dio_audio_packet,
261 .ext = {
262 .set_throttled_vcp_size = set_dio_throttled_vcp_size,
263 .enable_dp_link_output = enable_dio_dp_link_output,
264 .set_dp_link_test_pattern = set_dio_dp_link_test_pattern,
265 .set_dp_lane_settings = set_dio_dp_lane_settings,
266 .update_stream_allocation_table = update_dio_stream_allocation_table,
267 },
268 };
269
270 /**
271 * can_use_dio_link_hwss - Check if the link_hwss is accessible
272 *
273 * @link: Reference a link struct containing one or more sinks and the
274 * connective status.
275 * @link_res: Mappable hardware resource used to enable a link.
276 *
277 * Returns:
278 * Return true if the link encoder is accessible from link.
279 */
can_use_dio_link_hwss(const struct dc_link * link,const struct link_resource * link_res)280 bool can_use_dio_link_hwss(const struct dc_link *link,
281 const struct link_resource *link_res)
282 {
283 return link->link_enc != NULL;
284 }
285
286 /**
287 * get_dio_link_hwss - Return link_hwss reference
288 *
289 * This function behaves like a get function to return the link_hwss populated
290 * in the link_hwss_dio.c file.
291 *
292 * Returns:
293 * Return the reference to the filled struct of link_hwss.
294 */
get_dio_link_hwss(void)295 const struct link_hwss *get_dio_link_hwss(void)
296 {
297 return &dio_link_hwss;
298 }
299