projects/linux·blob master · refs

2044 lines · 58.5 KiB

1/*
2 * Copyright 2012-15 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#include "reg_helper.h"
27
28#include "core_types.h"
29#include "link_encoder.h"
30#include "dce_link_encoder.h"
31#include "stream_encoder.h"
32#include "dc_bios_types.h"
33
34#include "gpio_service_interface.h"
35
36#include "dce/dce_11_0_d.h"
37#include "dce/dce_11_0_sh_mask.h"
38#include "dce/dce_11_0_enum.h"
39
40#ifndef DMU_MEM_PWR_CNTL__DMCU_IRAM_MEM_PWR_STATE__SHIFT
41#define DMU_MEM_PWR_CNTL__DMCU_IRAM_MEM_PWR_STATE__SHIFT 0xa
42#endif
43
44#ifndef DMU_MEM_PWR_CNTL__DMCU_IRAM_MEM_PWR_STATE_MASK
45#define DMU_MEM_PWR_CNTL__DMCU_IRAM_MEM_PWR_STATE_MASK 0x00000400L
46#endif
47
48#ifndef HPD0_DC_HPD_CONTROL__DC_HPD_EN_MASK
49#define HPD0_DC_HPD_CONTROL__DC_HPD_EN_MASK 0x10000000L
50#endif
51
52#ifndef HPD0_DC_HPD_CONTROL__DC_HPD_EN__SHIFT
53#define HPD0_DC_HPD_CONTROL__DC_HPD_EN__SHIFT 0x1c
54#endif
55
56#define CTX \
57 enc110->base.ctx
58#define DC_LOGGER \
59 enc110->base.ctx->logger
60
61#define REG(reg)\
62 (enc110->link_regs->reg)
63
64#define AUX_REG(reg)\
65 (enc110->aux_regs->reg)
66
67#define HPD_REG(reg)\
68 (enc110->hpd_regs->reg)
69
70#define DEFAULT_AUX_MAX_DATA_SIZE 16
71#define AUX_MAX_DEFER_WRITE_RETRY 20
72/*
73 * @brief
74 * Trigger Source Select
75 * ASIC-dependent, actual values for register programming
76 */
77#define DCE110_DIG_FE_SOURCE_SELECT_INVALID 0x0
78#define DCE110_DIG_FE_SOURCE_SELECT_DIGA 0x1
79#define DCE110_DIG_FE_SOURCE_SELECT_DIGB 0x2
80#define DCE110_DIG_FE_SOURCE_SELECT_DIGC 0x4
81#define DCE110_DIG_FE_SOURCE_SELECT_DIGD 0x08
82#define DCE110_DIG_FE_SOURCE_SELECT_DIGE 0x10
83#define DCE110_DIG_FE_SOURCE_SELECT_DIGF 0x20
84#define DCE110_DIG_FE_SOURCE_SELECT_DIGG 0x40
85
86enum {
87 DP_MST_UPDATE_MAX_RETRY = 50
88};
89
90#define DIG_REG(reg)\
91 (reg + enc110->offsets.dig)
92
93#define DP_REG(reg)\
94 (reg + enc110->offsets.dp)
95
96static const struct link_encoder_funcs dce110_lnk_enc_funcs = {
97 .validate_output_with_stream =
98 dce110_link_encoder_validate_output_with_stream,
99 .hw_init = dce110_link_encoder_hw_init,
100 .setup = dce110_link_encoder_setup,
101 .enable_tmds_output = dce110_link_encoder_enable_tmds_output,
102 .enable_dp_output = dce110_link_encoder_enable_dp_output,
103 .enable_dp_mst_output = dce110_link_encoder_enable_dp_mst_output,
104 .enable_lvds_output = dce110_link_encoder_enable_lvds_output,
105 .enable_analog_output = dce110_link_encoder_enable_analog_output,
106 .disable_output = dce110_link_encoder_disable_output,
107 .dp_set_lane_settings = dce110_link_encoder_dp_set_lane_settings,
108 .dp_set_phy_pattern = dce110_link_encoder_dp_set_phy_pattern,
109 .update_mst_stream_allocation_table =
110 dce110_link_encoder_update_mst_stream_allocation_table,
111 .psr_program_dp_dphy_fast_training =
112 dce110_psr_program_dp_dphy_fast_training,
113 .psr_program_secondary_packet = dce110_psr_program_secondary_packet,
114 .connect_dig_be_to_fe = dce110_link_encoder_connect_dig_be_to_fe,
115 .enable_hpd = dce110_link_encoder_enable_hpd,
116 .disable_hpd = dce110_link_encoder_disable_hpd,
117 .is_dig_enabled = dce110_is_dig_enabled,
118 .destroy = dce110_link_encoder_destroy,
119 .get_max_link_cap = dce110_link_encoder_get_max_link_cap,
120 .get_dig_frontend = dce110_get_dig_frontend,
121 .get_hpd_state = dce110_get_hpd_state,
122 .program_hpd_filter = dce110_program_hpd_filter,
123};
124
125static const struct link_encoder_funcs dce110_lnk_enc_funcs_no_hpd = {
126 .validate_output_with_stream =
127 dce110_link_encoder_validate_output_with_stream,
128 .hw_init = dce110_link_encoder_hw_init,
129 .setup = dce110_link_encoder_setup,
130 .enable_tmds_output = dce110_link_encoder_enable_tmds_output,
131 .enable_dp_output = dce110_link_encoder_enable_dp_output,
132 .enable_dp_mst_output = dce110_link_encoder_enable_dp_mst_output,
133 .enable_lvds_output = dce110_link_encoder_enable_lvds_output,
134 .enable_analog_output = dce110_link_encoder_enable_analog_output,
135 .disable_output = dce110_link_encoder_disable_output,
136 .dp_set_lane_settings = dce110_link_encoder_dp_set_lane_settings,
137 .dp_set_phy_pattern = dce110_link_encoder_dp_set_phy_pattern,
138 .update_mst_stream_allocation_table =
139 dce110_link_encoder_update_mst_stream_allocation_table,
140 .psr_program_dp_dphy_fast_training =
141 dce110_psr_program_dp_dphy_fast_training,
142 .psr_program_secondary_packet = dce110_psr_program_secondary_packet,
143 .connect_dig_be_to_fe = dce110_link_encoder_connect_dig_be_to_fe,
144 .is_dig_enabled = dce110_is_dig_enabled,
145 .destroy = dce110_link_encoder_destroy,
146 .get_max_link_cap = dce110_link_encoder_get_max_link_cap,
147 .get_dig_frontend = dce110_get_dig_frontend,
148 .get_hpd_state = dce110_get_hpd_state,
149 .program_hpd_filter = dce110_program_hpd_filter,
150};
151
152static enum bp_result link_transmitter_control(
153 struct dce110_link_encoder *enc110,
154 struct bp_transmitter_control *cntl)
155{
156 enum bp_result result;
157 struct dc_bios *bp = enc110->base.ctx->dc_bios;
158
159 result = bp->funcs->transmitter_control(bp, cntl);
160
161 return result;
162}
163
164static enum bp_result link_dac_encoder_control(
165 struct dce110_link_encoder *link_enc,
166 enum bp_encoder_control_action action,
167 uint32_t pix_clk_100hz)
168{
169 struct dc_bios *bios = link_enc->base.ctx->dc_bios;
170 struct bp_encoder_control encoder_control = {0};
171
172 encoder_control.action = action;
173 encoder_control.engine_id = link_enc->base.analog_engine;
174 encoder_control.pixel_clock = pix_clk_100hz / 10;
175
176 return bios->funcs->encoder_control(bios, &encoder_control);
177}
178
179static void enable_phy_bypass_mode(
180 struct dce110_link_encoder *enc110,
181 bool enable)
182{
183 /* This register resides in DP back end block;
184 * transmitter is used for the offset */
185
186 REG_UPDATE(DP_DPHY_CNTL, DPHY_BYPASS, enable);
187
188}
189
190static void disable_prbs_symbols(
191 struct dce110_link_encoder *enc110,
192 bool disable)
193{
194 /* This register resides in DP back end block;
195 * transmitter is used for the offset */
196
197 REG_UPDATE_4(DP_DPHY_CNTL,
198 DPHY_ATEST_SEL_LANE0, disable,
199 DPHY_ATEST_SEL_LANE1, disable,
200 DPHY_ATEST_SEL_LANE2, disable,
201 DPHY_ATEST_SEL_LANE3, disable);
202}
203
204static void disable_prbs_mode(
205 struct dce110_link_encoder *enc110)
206{
207 REG_UPDATE(DP_DPHY_PRBS_CNTL, DPHY_PRBS_EN, 0);
208}
209
210static void program_pattern_symbols(
211 struct dce110_link_encoder *enc110,
212 uint16_t pattern_symbols[8])
213{
214 /* This register resides in DP back end block;
215 * transmitter is used for the offset */
216
217 REG_SET_3(DP_DPHY_SYM0, 0,
218 DPHY_SYM1, pattern_symbols[0],
219 DPHY_SYM2, pattern_symbols[1],
220 DPHY_SYM3, pattern_symbols[2]);
221
222 /* This register resides in DP back end block;
223 * transmitter is used for the offset */
224
225 REG_SET_3(DP_DPHY_SYM1, 0,
226 DPHY_SYM4, pattern_symbols[3],
227 DPHY_SYM5, pattern_symbols[4],
228 DPHY_SYM6, pattern_symbols[5]);
229
230 /* This register resides in DP back end block;
231 * transmitter is used for the offset */
232
233 REG_SET_2(DP_DPHY_SYM2, 0,
234 DPHY_SYM7, pattern_symbols[6],
235 DPHY_SYM8, pattern_symbols[7]);
236}
237
238static void set_dp_phy_pattern_d102(
239 struct dce110_link_encoder *enc110)
240{
241 /* Disable PHY Bypass mode to setup the test pattern */
242 enable_phy_bypass_mode(enc110, false);
243
244 /* For 10-bit PRBS or debug symbols
245 * please use the following sequence: */
246
247 /* Enable debug symbols on the lanes */
248
249 disable_prbs_symbols(enc110, true);
250
251 /* Disable PRBS mode */
252 disable_prbs_mode(enc110);
253
254 /* Program debug symbols to be output */
255 {
256 uint16_t pattern_symbols[8] = {
257 0x2AA, 0x2AA, 0x2AA, 0x2AA,
258 0x2AA, 0x2AA, 0x2AA, 0x2AA
259 };
260
261 program_pattern_symbols(enc110, pattern_symbols);
262 }
263
264 /* Enable phy bypass mode to enable the test pattern */
265
266 enable_phy_bypass_mode(enc110, true);
267}
268
269static void set_link_training_complete(
270 struct dce110_link_encoder *enc110,
271 bool complete)
272{
273 /* This register resides in DP back end block;
274 * transmitter is used for the offset */
275
276 REG_UPDATE(DP_LINK_CNTL, DP_LINK_TRAINING_COMPLETE, complete);
277
278}
279
280unsigned int dce110_get_dig_frontend(struct link_encoder *enc)
281{
282 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
283 u32 value;
284 enum engine_id result;
285
286 REG_GET(DIG_BE_CNTL, DIG_FE_SOURCE_SELECT, &value);
287
288 switch (value) {
289 case DCE110_DIG_FE_SOURCE_SELECT_DIGA:
290 result = ENGINE_ID_DIGA;
291 break;
292 case DCE110_DIG_FE_SOURCE_SELECT_DIGB:
293 result = ENGINE_ID_DIGB;
294 break;
295 case DCE110_DIG_FE_SOURCE_SELECT_DIGC:
296 result = ENGINE_ID_DIGC;
297 break;
298 case DCE110_DIG_FE_SOURCE_SELECT_DIGD:
299 result = ENGINE_ID_DIGD;
300 break;
301 case DCE110_DIG_FE_SOURCE_SELECT_DIGE:
302 result = ENGINE_ID_DIGE;
303 break;
304 case DCE110_DIG_FE_SOURCE_SELECT_DIGF:
305 result = ENGINE_ID_DIGF;
306 break;
307 case DCE110_DIG_FE_SOURCE_SELECT_DIGG:
308 result = ENGINE_ID_DIGG;
309 break;
310 default:
311 // invalid source select DIG
312 result = ENGINE_ID_UNKNOWN;
313 }
314
315 return result;
316}
317
318void dce110_link_encoder_set_dp_phy_pattern_training_pattern(
319 struct link_encoder *enc,
320 uint32_t index)
321{
322 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
323 /* Write Training Pattern */
324
325 REG_WRITE(DP_DPHY_TRAINING_PATTERN_SEL, index);
326
327 /* Set HW Register Training Complete to false */
328
329 set_link_training_complete(enc110, false);
330
331 /* Disable PHY Bypass mode to output Training Pattern */
332
333 enable_phy_bypass_mode(enc110, false);
334
335 /* Disable PRBS mode */
336 disable_prbs_mode(enc110);
337}
338
339static void setup_panel_mode(
340 struct dce110_link_encoder *enc110,
341 enum dp_panel_mode panel_mode)
342{
343 uint32_t value;
344 struct dc_context *ctx = enc110->base.ctx;
345
346 /* if psp set panel mode, dal should be program it */
347 if (ctx->dc->caps.psp_setup_panel_mode)
348 return;
349
350 /* The code below is only applicable to encoders with a digital transmitter. */
351 if (enc110->base.transmitter == TRANSMITTER_UNKNOWN)
352 return;
353
354 ASSERT(REG(DP_DPHY_INTERNAL_CTRL));
355 value = REG_READ(DP_DPHY_INTERNAL_CTRL);
356
357 switch (panel_mode) {
358 case DP_PANEL_MODE_EDP:
359 value = 0x1;
360 break;
361 case DP_PANEL_MODE_SPECIAL:
362 value = 0x11;
363 break;
364 default:
365 value = 0x0;
366 break;
367 }
368
369 REG_WRITE(DP_DPHY_INTERNAL_CTRL, value);
370}
371
372static void set_dp_phy_pattern_symbol_error(
373 struct dce110_link_encoder *enc110)
374{
375 /* Disable PHY Bypass mode to setup the test pattern */
376 enable_phy_bypass_mode(enc110, false);
377
378 /* program correct panel mode*/
379 setup_panel_mode(enc110, DP_PANEL_MODE_DEFAULT);
380
381 /* A PRBS23 pattern is used for most DP electrical measurements. */
382
383 /* Enable PRBS symbols on the lanes */
384 disable_prbs_symbols(enc110, false);
385
386 /* For PRBS23 Set bit DPHY_PRBS_SEL=1 and Set bit DPHY_PRBS_EN=1 */
387 REG_UPDATE_2(DP_DPHY_PRBS_CNTL,
388 DPHY_PRBS_SEL, 1,
389 DPHY_PRBS_EN, 1);
390
391 /* Enable phy bypass mode to enable the test pattern */
392 enable_phy_bypass_mode(enc110, true);
393}
394
395static void set_dp_phy_pattern_prbs7(
396 struct dce110_link_encoder *enc110)
397{
398 /* Disable PHY Bypass mode to setup the test pattern */
399 enable_phy_bypass_mode(enc110, false);
400
401 /* A PRBS7 pattern is used for most DP electrical measurements. */
402
403 /* Enable PRBS symbols on the lanes */
404 disable_prbs_symbols(enc110, false);
405
406 /* For PRBS7 Set bit DPHY_PRBS_SEL=0 and Set bit DPHY_PRBS_EN=1 */
407 REG_UPDATE_2(DP_DPHY_PRBS_CNTL,
408 DPHY_PRBS_SEL, 0,
409 DPHY_PRBS_EN, 1);
410
411 /* Enable phy bypass mode to enable the test pattern */
412 enable_phy_bypass_mode(enc110, true);
413}
414
415static void set_dp_phy_pattern_80bit_custom(
416 struct dce110_link_encoder *enc110,
417 const uint8_t *pattern)
418{
419 /* Disable PHY Bypass mode to setup the test pattern */
420 enable_phy_bypass_mode(enc110, false);
421
422 /* Enable debug symbols on the lanes */
423
424 disable_prbs_symbols(enc110, true);
425
426 /* Enable PHY bypass mode to enable the test pattern */
427 /* TODO is it really needed ? */
428
429 enable_phy_bypass_mode(enc110, true);
430
431 /* Program 80 bit custom pattern */
432 {
433 uint16_t pattern_symbols[8];
434
435 pattern_symbols[0] =
436 ((pattern[1] & 0x03) << 8) | pattern[0];
437 pattern_symbols[1] =
438 ((pattern[2] & 0x0f) << 6) | ((pattern[1] >> 2) & 0x3f);
439 pattern_symbols[2] =
440 ((pattern[3] & 0x3f) << 4) | ((pattern[2] >> 4) & 0x0f);
441 pattern_symbols[3] =
442 (pattern[4] << 2) | ((pattern[3] >> 6) & 0x03);
443 pattern_symbols[4] =
444 ((pattern[6] & 0x03) << 8) | pattern[5];
445 pattern_symbols[5] =
446 ((pattern[7] & 0x0f) << 6) | ((pattern[6] >> 2) & 0x3f);
447 pattern_symbols[6] =
448 ((pattern[8] & 0x3f) << 4) | ((pattern[7] >> 4) & 0x0f);
449 pattern_symbols[7] =
450 (pattern[9] << 2) | ((pattern[8] >> 6) & 0x03);
451
452 program_pattern_symbols(enc110, pattern_symbols);
453 }
454
455 /* Enable phy bypass mode to enable the test pattern */
456
457 enable_phy_bypass_mode(enc110, true);
458}
459
460static void set_dp_phy_pattern_hbr2_compliance_cp2520_2(
461 struct dce110_link_encoder *enc110,
462 unsigned int cp2520_pattern)
463{
464
465 /* previously there is a register DP_HBR2_EYE_PATTERN
466 * that is enabled to get the pattern.
467 * But it does not work with the latest spec change,
468 * so we are programming the following registers manually.
469 *
470 * The following settings have been confirmed
471 * by Nick Chorney and Sandra Liu */
472
473 /* Disable PHY Bypass mode to setup the test pattern */
474
475 enable_phy_bypass_mode(enc110, false);
476
477 /* Setup DIG encoder in DP SST mode */
478 enc110->base.funcs->setup(&enc110->base, SIGNAL_TYPE_DISPLAY_PORT);
479
480 /* ensure normal panel mode. */
481 setup_panel_mode(enc110, DP_PANEL_MODE_DEFAULT);
482
483 /* no vbid after BS (SR)
484 * DP_LINK_FRAMING_CNTL changed history Sandra Liu
485 * 11000260 / 11000104 / 110000FC */
486 REG_UPDATE_3(DP_LINK_FRAMING_CNTL,
487 DP_IDLE_BS_INTERVAL, 0xFC,
488 DP_VBID_DISABLE, 1,
489 DP_VID_ENHANCED_FRAME_MODE, 1);
490
491 /* swap every BS with SR */
492 REG_UPDATE(DP_DPHY_SCRAM_CNTL, DPHY_SCRAMBLER_BS_COUNT, 0);
493
494 /* select cp2520 patterns */
495 if (REG(DP_DPHY_HBR2_PATTERN_CONTROL))
496 REG_UPDATE(DP_DPHY_HBR2_PATTERN_CONTROL,
497 DP_DPHY_HBR2_PATTERN_CONTROL, cp2520_pattern);
498 else
499 /* pre-DCE11 can only generate CP2520 pattern 2 */
500 ASSERT(cp2520_pattern == 2);
501
502 /* set link training complete */
503 set_link_training_complete(enc110, true);
504
505 /* disable video stream */
506 REG_UPDATE(DP_VID_STREAM_CNTL, DP_VID_STREAM_ENABLE, 0);
507
508 /* Disable PHY Bypass mode to setup the test pattern */
509 enable_phy_bypass_mode(enc110, false);
510}
511
512#if defined(CONFIG_DRM_AMD_DC_SI)
513static void dce60_set_dp_phy_pattern_hbr2_compliance_cp2520_2(
514 struct dce110_link_encoder *enc110,
515 unsigned int cp2520_pattern)
516{
517
518 /* previously there is a register DP_HBR2_EYE_PATTERN
519 * that is enabled to get the pattern.
520 * But it does not work with the latest spec change,
521 * so we are programming the following registers manually.
522 *
523 * The following settings have been confirmed
524 * by Nick Chorney and Sandra Liu */
525
526 /* Disable PHY Bypass mode to setup the test pattern */
527
528 enable_phy_bypass_mode(enc110, false);
529
530 /* Setup DIG encoder in DP SST mode */
531 enc110->base.funcs->setup(&enc110->base, SIGNAL_TYPE_DISPLAY_PORT);
532
533 /* ensure normal panel mode. */
534 setup_panel_mode(enc110, DP_PANEL_MODE_DEFAULT);
535
536 /* no vbid after BS (SR)
537 * DP_LINK_FRAMING_CNTL changed history Sandra Liu
538 * 11000260 / 11000104 / 110000FC */
539 REG_UPDATE_3(DP_LINK_FRAMING_CNTL,
540 DP_IDLE_BS_INTERVAL, 0xFC,
541 DP_VBID_DISABLE, 1,
542 DP_VID_ENHANCED_FRAME_MODE, 1);
543
544 /* DCE6 has no DP_DPHY_SCRAM_CNTL register, skip swap BS with SR */
545
546 /* select cp2520 patterns */
547 if (REG(DP_DPHY_HBR2_PATTERN_CONTROL))
548 REG_UPDATE(DP_DPHY_HBR2_PATTERN_CONTROL,
549 DP_DPHY_HBR2_PATTERN_CONTROL, cp2520_pattern);
550 else
551 /* pre-DCE11 can only generate CP2520 pattern 2 */
552 ASSERT(cp2520_pattern == 2);
553
554 /* set link training complete */
555 set_link_training_complete(enc110, true);
556
557 /* disable video stream */
558 REG_UPDATE(DP_VID_STREAM_CNTL, DP_VID_STREAM_ENABLE, 0);
559
560 /* Disable PHY Bypass mode to setup the test pattern */
561 enable_phy_bypass_mode(enc110, false);
562}
563#endif
564
565static void set_dp_phy_pattern_passthrough_mode(
566 struct dce110_link_encoder *enc110,
567 enum dp_panel_mode panel_mode)
568{
569 /* program correct panel mode */
570 setup_panel_mode(enc110, panel_mode);
571
572 /* restore LINK_FRAMING_CNTL and DPHY_SCRAMBLER_BS_COUNT
573 * in case we were doing HBR2 compliance pattern before
574 */
575 REG_UPDATE_3(DP_LINK_FRAMING_CNTL,
576 DP_IDLE_BS_INTERVAL, 0x2000,
577 DP_VBID_DISABLE, 0,
578 DP_VID_ENHANCED_FRAME_MODE, 1);
579
580 REG_UPDATE(DP_DPHY_SCRAM_CNTL, DPHY_SCRAMBLER_BS_COUNT, 0x1FF);
581
582 /* set link training complete */
583 set_link_training_complete(enc110, true);
584
585 /* Disable PHY Bypass mode to setup the test pattern */
586 enable_phy_bypass_mode(enc110, false);
587
588 /* Disable PRBS mode */
589 disable_prbs_mode(enc110);
590}
591
592#if defined(CONFIG_DRM_AMD_DC_SI)
593static void dce60_set_dp_phy_pattern_passthrough_mode(
594 struct dce110_link_encoder *enc110,
595 enum dp_panel_mode panel_mode)
596{
597 /* program correct panel mode */
598 setup_panel_mode(enc110, panel_mode);
599
600 /* restore LINK_FRAMING_CNTL
601 * in case we were doing HBR2 compliance pattern before
602 */
603 REG_UPDATE_3(DP_LINK_FRAMING_CNTL,
604 DP_IDLE_BS_INTERVAL, 0x2000,
605 DP_VBID_DISABLE, 0,
606 DP_VID_ENHANCED_FRAME_MODE, 1);
607
608 /* DCE6 has no DP_DPHY_SCRAM_CNTL register, skip DPHY_SCRAMBLER_BS_COUNT restore */
609
610 /* set link training complete */
611 set_link_training_complete(enc110, true);
612
613 /* Disable PHY Bypass mode to setup the test pattern */
614 enable_phy_bypass_mode(enc110, false);
615
616 /* Disable PRBS mode */
617 disable_prbs_mode(enc110);
618}
619#endif
620
621/* return value is bit-vector */
622static uint8_t get_frontend_source(
623 enum engine_id engine)
624{
625 switch (engine) {
626 case ENGINE_ID_DIGA:
627 return DCE110_DIG_FE_SOURCE_SELECT_DIGA;
628 case ENGINE_ID_DIGB:
629 return DCE110_DIG_FE_SOURCE_SELECT_DIGB;
630 case ENGINE_ID_DIGC:
631 return DCE110_DIG_FE_SOURCE_SELECT_DIGC;
632 case ENGINE_ID_DIGD:
633 return DCE110_DIG_FE_SOURCE_SELECT_DIGD;
634 case ENGINE_ID_DIGE:
635 return DCE110_DIG_FE_SOURCE_SELECT_DIGE;
636 case ENGINE_ID_DIGF:
637 return DCE110_DIG_FE_SOURCE_SELECT_DIGF;
638 case ENGINE_ID_DIGG:
639 return DCE110_DIG_FE_SOURCE_SELECT_DIGG;
640 default:
641 ASSERT_CRITICAL(false);
642 return DCE110_DIG_FE_SOURCE_SELECT_INVALID;
643 }
644}
645
646static void configure_encoder(
647 struct dce110_link_encoder *enc110,
648 const struct dc_link_settings *link_settings)
649{
650 /* set number of lanes */
651
652 REG_SET(DP_CONFIG, 0,
653 DP_UDI_LANES, link_settings->lane_count - LANE_COUNT_ONE);
654
655 /* setup scrambler */
656 REG_UPDATE(DP_DPHY_SCRAM_CNTL, DPHY_SCRAMBLER_ADVANCE, 1);
657}
658
659#if defined(CONFIG_DRM_AMD_DC_SI)
660static void dce60_configure_encoder(
661 struct dce110_link_encoder *enc110,
662 const struct dc_link_settings *link_settings)
663{
664 /* set number of lanes */
665
666 REG_SET(DP_CONFIG, 0,
667 DP_UDI_LANES, link_settings->lane_count - LANE_COUNT_ONE);
668
669 /* DCE6 has no DP_DPHY_SCRAM_CNTL register, skip setup scrambler */
670}
671#endif
672
673static void aux_initialize(
674 struct dce110_link_encoder *enc110)
675{
676 struct dc_context *ctx = enc110->base.ctx;
677 enum hpd_source_id hpd_source = enc110->base.hpd_source;
678 uint32_t addr = AUX_REG(AUX_CONTROL);
679 uint32_t value = dm_read_reg(ctx, addr);
680
681 set_reg_field_value(value, hpd_source, AUX_CONTROL, AUX_HPD_SEL);
682 set_reg_field_value(value, 0, AUX_CONTROL, AUX_LS_READ_EN);
683 dm_write_reg(ctx, addr, value);
684
685 addr = AUX_REG(AUX_DPHY_RX_CONTROL0);
686 value = dm_read_reg(ctx, addr);
687
688 /* 1/4 window (the maximum allowed) */
689 set_reg_field_value(value, 1,
690 AUX_DPHY_RX_CONTROL0, AUX_RX_RECEIVE_WINDOW);
691 dm_write_reg(ctx, addr, value);
692
693}
694
695void dce110_psr_program_dp_dphy_fast_training(struct link_encoder *enc,
696 bool exit_link_training_required)
697{
698 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
699
700 if (exit_link_training_required)
701 REG_UPDATE(DP_DPHY_FAST_TRAINING,
702 DPHY_RX_FAST_TRAINING_CAPABLE, 1);
703 else {
704 REG_UPDATE(DP_DPHY_FAST_TRAINING,
705 DPHY_RX_FAST_TRAINING_CAPABLE, 0);
706 /*In DCE 11, we are able to pre-program a Force SR register
707 * to be able to trigger SR symbol after 5 idle patterns
708 * transmitted. Upon PSR Exit, DMCU can trigger
709 * DPHY_LOAD_BS_COUNT_START = 1. Upon writing 1 to
710 * DPHY_LOAD_BS_COUNT_START and the internal counter
711 * reaches DPHY_LOAD_BS_COUNT, the next BS symbol will be
712 * replaced by SR symbol once.
713 */
714
715 REG_UPDATE(DP_DPHY_BS_SR_SWAP_CNTL, DPHY_LOAD_BS_COUNT, 0x5);
716 }
717}
718
719void dce110_psr_program_secondary_packet(struct link_encoder *enc,
720 unsigned int sdp_transmit_line_num_deadline)
721{
722 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
723
724 REG_UPDATE_2(DP_SEC_CNTL1,
725 DP_SEC_GSP0_LINE_NUM, sdp_transmit_line_num_deadline,
726 DP_SEC_GSP0_PRIORITY, 1);
727}
728
729bool dce110_is_dig_enabled(struct link_encoder *enc)
730{
731 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
732 uint32_t value;
733
734 REG_GET(DIG_BE_EN_CNTL, DIG_ENABLE, &value);
735 return value;
736}
737
738static void link_encoder_disable(struct dce110_link_encoder *enc110)
739{
740 /* reset training pattern */
741 REG_SET(DP_DPHY_TRAINING_PATTERN_SEL, 0,
742 DPHY_TRAINING_PATTERN_SEL, 0);
743
744 /* reset training complete */
745 REG_UPDATE(DP_LINK_CNTL, DP_LINK_TRAINING_COMPLETE, 0);
746
747 /* reset panel mode */
748 setup_panel_mode(enc110, DP_PANEL_MODE_DEFAULT);
749}
750
751static void hpd_initialize(
752 struct dce110_link_encoder *enc110)
753{
754 /* Associate HPD with DIG_BE */
755 enum hpd_source_id hpd_source = enc110->base.hpd_source;
756
757 REG_UPDATE(DIG_BE_CNTL, DIG_HPD_SELECT, hpd_source);
758}
759
760bool dce110_link_encoder_validate_dvi_output(
761 const struct dce110_link_encoder *enc110,
762 enum signal_type connector_signal,
763 enum signal_type signal,
764 const struct dc_crtc_timing *crtc_timing)
765{
766 uint32_t max_pixel_clock = TMDS_MAX_PIXEL_CLOCK;
767
768 if (signal == SIGNAL_TYPE_DVI_DUAL_LINK)
769 max_pixel_clock *= 2;
770
771 /* This handles the case of HDMI downgrade to DVI we don't want to
772 * we don't want to cap the pixel clock if the DDI is not DVI.
773 */
774 if (connector_signal != SIGNAL_TYPE_DVI_DUAL_LINK &&
775 connector_signal != SIGNAL_TYPE_DVI_SINGLE_LINK)
776 max_pixel_clock = enc110->base.features.max_hdmi_pixel_clock;
777
778 /* DVI only support RGB pixel encoding */
779 if (crtc_timing->pixel_encoding != PIXEL_ENCODING_RGB)
780 return false;
781
782 /*connect DVI via adpater's HDMI connector*/
783 if ((connector_signal == SIGNAL_TYPE_DVI_SINGLE_LINK ||
784 connector_signal == SIGNAL_TYPE_HDMI_TYPE_A) &&
785 signal != SIGNAL_TYPE_HDMI_TYPE_A &&
786 crtc_timing->pix_clk_100hz > (TMDS_MAX_PIXEL_CLOCK * 10))
787 return false;
788 if (crtc_timing->pix_clk_100hz < (TMDS_MIN_PIXEL_CLOCK * 10))
789 return false;
790
791 if (crtc_timing->pix_clk_100hz > (max_pixel_clock * 10))
792 return false;
793
794 /* DVI supports 6/8bpp single-link and 10/16bpp dual-link */
795 switch (crtc_timing->display_color_depth) {
796 case COLOR_DEPTH_666:
797 case COLOR_DEPTH_888:
798 break;
799 case COLOR_DEPTH_101010:
800 case COLOR_DEPTH_161616:
801 if (signal != SIGNAL_TYPE_DVI_DUAL_LINK)
802 return false;
803 break;
804 default:
805 return false;
806 }
807
808 return true;
809}
810
811static bool dce110_link_encoder_validate_hdmi_output(
812 const struct dce110_link_encoder *enc110,
813 const struct dc_crtc_timing *crtc_timing,
814 int adjusted_pix_clk_khz)
815{
816 enum dc_color_depth max_deep_color =
817 enc110->base.features.max_hdmi_deep_color;
818 int max_hdmi_pixel_clock_khz = (int)enc110->base.features.max_hdmi_pixel_clock;
819
820 if (max_deep_color < crtc_timing->display_color_depth)
821 return false;
822
823 if (crtc_timing->display_color_depth < COLOR_DEPTH_888)
824 return false;
825 if (adjusted_pix_clk_khz < TMDS_MIN_PIXEL_CLOCK)
826 return false;
827
828 if ((adjusted_pix_clk_khz == 0) ||
829 (adjusted_pix_clk_khz > max_hdmi_pixel_clock_khz))
830 return false;
831
832 /* DCE11 HW does not support 420 */
833 if (!enc110->base.features.hdmi_ycbcr420_supported &&
834 crtc_timing->pixel_encoding == PIXEL_ENCODING_YCBCR420)
835 return false;
836
837 if ((!enc110->base.features.flags.bits.HDMI_6GB_EN ||
838 enc110->base.ctx->dc->debug.hdmi20_disable) &&
839 adjusted_pix_clk_khz >= 300000)
840 return false;
841 if (enc110->base.ctx->dc->debug.hdmi20_disable &&
842 crtc_timing->pixel_encoding == PIXEL_ENCODING_YCBCR420)
843 return false;
844 return true;
845}
846
847bool dce110_link_encoder_validate_dp_output(
848 const struct dce110_link_encoder *enc110,
849 const struct dc_crtc_timing *crtc_timing)
850{
851 (void)enc110;
852 if (crtc_timing->pixel_encoding == PIXEL_ENCODING_YCBCR420)
853 return false;
854
855 return true;
856}
857
858static bool dce110_link_encoder_validate_rgb_output(
859 const struct dce110_link_encoder *enc110,
860 const struct dc_crtc_timing *crtc_timing)
861{
862 /* When the VBIOS doesn't specify any limits, use 400 MHz.
863 * The value comes from amdgpu_atombios_get_clock_info.
864 */
865 uint32_t max_pixel_clock_khz = 400000;
866
867 if (enc110->base.ctx->dc_bios->fw_info_valid &&
868 enc110->base.ctx->dc_bios->fw_info.max_pixel_clock) {
869 max_pixel_clock_khz =
870 enc110->base.ctx->dc_bios->fw_info.max_pixel_clock;
871 }
872
873 if (crtc_timing->pix_clk_100hz > max_pixel_clock_khz * 10)
874 return false;
875
876 if (crtc_timing->display_color_depth != COLOR_DEPTH_888)
877 return false;
878
879 if (crtc_timing->pixel_encoding != PIXEL_ENCODING_RGB)
880 return false;
881
882 return true;
883}
884
885void dce110_link_encoder_construct(
886 struct dce110_link_encoder *enc110,
887 const struct encoder_init_data *init_data,
888 const struct encoder_feature_support *enc_features,
889 const struct dce110_link_enc_registers *link_regs,
890 const struct dce110_link_enc_aux_registers *aux_regs,
891 const struct dce110_link_enc_hpd_registers *hpd_regs)
892{
893 struct bp_encoder_cap_info bp_cap_info = {0};
894 const struct dc_vbios_funcs *bp_funcs = init_data->ctx->dc_bios->funcs;
895 enum bp_result result = BP_RESULT_OK;
896
897 if (hpd_regs)
898 enc110->base.funcs = &dce110_lnk_enc_funcs;
899 else
900 enc110->base.funcs = &dce110_lnk_enc_funcs_no_hpd;
901 enc110->base.ctx = init_data->ctx;
902 enc110->base.id = init_data->encoder;
903 enc110->base.analog_id = init_data->analog_encoder;
904
905 enc110->base.hpd_gpio = init_data->hpd_gpio;
906 enc110->base.hpd_source = init_data->hpd_source;
907 enc110->base.connector = init_data->connector;
908
909 enc110->base.preferred_engine = ENGINE_ID_UNKNOWN;
910 enc110->base.analog_engine = init_data->analog_engine;
911
912 enc110->base.features = *enc_features;
913
914 enc110->base.transmitter = init_data->transmitter;
915
916 /* set the flag to indicate whether driver poll the I2C data pin
917 * while doing the DP sink detect
918 */
919
920/* if (dal_adapter_service_is_feature_supported(as,
921 FEATURE_DP_SINK_DETECT_POLL_DATA_PIN))
922 enc110->base.features.flags.bits.
923 DP_SINK_DETECT_POLL_DATA_PIN = true;*/
924
925 enc110->base.output_signals =
926 SIGNAL_TYPE_DVI_SINGLE_LINK |
927 SIGNAL_TYPE_DVI_DUAL_LINK |
928 SIGNAL_TYPE_LVDS |
929 SIGNAL_TYPE_DISPLAY_PORT |
930 SIGNAL_TYPE_DISPLAY_PORT_MST |
931 SIGNAL_TYPE_EDP |
932 SIGNAL_TYPE_HDMI_TYPE_A;
933
934 if ((enc110->base.connector.id == CONNECTOR_ID_DUAL_LINK_DVII ||
935 enc110->base.connector.id == CONNECTOR_ID_SINGLE_LINK_DVII) &&
936 enc110->base.analog_engine != ENGINE_ID_UNKNOWN)
937 enc110->base.output_signals |= SIGNAL_TYPE_RGB;
938
939 /* For DCE 8.0 and 8.1, by design, UNIPHY is hardwired to DIG_BE.
940 * SW always assign DIG_FE 1:1 mapped to DIG_FE for non-MST UNIPHY.
941 * SW assign DIG_FE to non-MST UNIPHY first and MST last. So prefer
942 * DIG is per UNIPHY and used by SST DP, eDP, HDMI, DVI and LVDS.
943 * Prefer DIG assignment is decided by board design.
944 * For DCE 8.0, there are only max 6 UNIPHYs, we assume board design
945 * and VBIOS will filter out 7 UNIPHY for DCE 8.0.
946 * By this, adding DIGG should not hurt DCE 8.0.
947 * This will let DCE 8.1 share DCE 8.0 as much as possible
948 */
949
950 enc110->link_regs = link_regs;
951 enc110->aux_regs = aux_regs;
952 enc110->hpd_regs = hpd_regs;
953
954 switch (enc110->base.transmitter) {
955 case TRANSMITTER_UNIPHY_A:
956 enc110->base.preferred_engine = ENGINE_ID_DIGA;
957 break;
958 case TRANSMITTER_UNIPHY_B:
959 enc110->base.preferred_engine = ENGINE_ID_DIGB;
960 break;
961 case TRANSMITTER_UNIPHY_C:
962 enc110->base.preferred_engine = ENGINE_ID_DIGC;
963 break;
964 case TRANSMITTER_UNIPHY_D:
965 enc110->base.preferred_engine = ENGINE_ID_DIGD;
966 break;
967 case TRANSMITTER_UNIPHY_E:
968 enc110->base.preferred_engine = ENGINE_ID_DIGE;
969 break;
970 case TRANSMITTER_UNIPHY_F:
971 enc110->base.preferred_engine = ENGINE_ID_DIGF;
972 break;
973 case TRANSMITTER_UNIPHY_G:
974 enc110->base.preferred_engine = ENGINE_ID_DIGG;
975 break;
976 default:
977 if (init_data->analog_engine != ENGINE_ID_UNKNOWN) {
978 /* The connector is analog-only, ie. VGA */
979 enc110->base.preferred_engine = init_data->analog_engine;
980 enc110->base.output_signals = SIGNAL_TYPE_RGB;
981 enc110->base.transmitter = TRANSMITTER_UNKNOWN;
982 break;
983 }
984 ASSERT_CRITICAL(false);
985 enc110->base.preferred_engine = ENGINE_ID_UNKNOWN;
986 }
987
988 /* default to one to mirror Windows behavior */
989 enc110->base.features.flags.bits.HDMI_6GB_EN = 1;
990
991 result = bp_funcs->get_encoder_cap_info(enc110->base.ctx->dc_bios,
992 enc110->base.id, &bp_cap_info);
993
994 /* Override features with DCE-specific values */
995 if (result == BP_RESULT_OK) {
996 enc110->base.features.flags.bits.IS_HBR2_CAPABLE =
997 bp_cap_info.DP_HBR2_EN;
998 enc110->base.features.flags.bits.IS_HBR3_CAPABLE =
999 bp_cap_info.DP_HBR3_EN;
1000 enc110->base.features.flags.bits.HDMI_6GB_EN = bp_cap_info.HDMI_6GB_EN;
1001 } else if (result != BP_RESULT_NORECORD) {
1002 DC_LOG_WARNING("%s: Failed to get encoder_cap_info from VBIOS with error code %d!\n",
1003 __func__,
1004 result);
1005 }
1006 if (enc110->base.ctx->dc->debug.hdmi20_disable) {
1007 enc110->base.features.flags.bits.HDMI_6GB_EN = 0;
1008 }
1009}
1010
1011bool dce110_link_encoder_validate_output_with_stream(
1012 struct link_encoder *enc,
1013 const struct dc_stream_state *stream)
1014{
1015 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
1016 bool is_valid;
1017
1018 switch (stream->signal) {
1019 case SIGNAL_TYPE_DVI_SINGLE_LINK:
1020 case SIGNAL_TYPE_DVI_DUAL_LINK:
1021 is_valid = dce110_link_encoder_validate_dvi_output(
1022 enc110,
1023 stream->link->connector_signal,
1024 stream->signal,
1025 &stream->timing);
1026 break;
1027 case SIGNAL_TYPE_HDMI_TYPE_A:
1028 is_valid = dce110_link_encoder_validate_hdmi_output(
1029 enc110,
1030 &stream->timing,
1031 stream->phy_pix_clk);
1032 break;
1033 case SIGNAL_TYPE_DISPLAY_PORT:
1034 case SIGNAL_TYPE_DISPLAY_PORT_MST:
1035 is_valid = dce110_link_encoder_validate_dp_output(
1036 enc110, &stream->timing);
1037 break;
1038 case SIGNAL_TYPE_RGB:
1039 is_valid = dce110_link_encoder_validate_rgb_output(
1040 enc110, &stream->timing);
1041 break;
1042 case SIGNAL_TYPE_EDP:
1043 case SIGNAL_TYPE_LVDS:
1044 is_valid = stream->timing.pixel_encoding == PIXEL_ENCODING_RGB;
1045 break;
1046 case SIGNAL_TYPE_VIRTUAL:
1047 is_valid = true;
1048 break;
1049 default:
1050 is_valid = false;
1051 break;
1052 }
1053
1054 return is_valid;
1055}
1056
1057void dce110_link_encoder_hw_init(
1058 struct link_encoder *enc)
1059{
1060 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
1061 struct bp_transmitter_control cntl = { 0 };
1062 enum bp_result result;
1063
1064 cntl.action = TRANSMITTER_CONTROL_INIT;
1065 cntl.engine_id = ENGINE_ID_UNKNOWN;
1066 cntl.transmitter = enc110->base.transmitter;
1067 cntl.connector_obj_id = enc110->base.connector;
1068 cntl.lanes_number = LANE_COUNT_FOUR;
1069 cntl.coherent = false;
1070 cntl.hpd_sel = enc110->base.hpd_source;
1071
1072 if (enc110->base.analog_engine != ENGINE_ID_UNKNOWN) {
1073 result = link_dac_encoder_control(enc110, ENCODER_CONTROL_INIT, 0);
1074 if (result != BP_RESULT_OK) {
1075 DC_LOG_ERROR("%s: Failed to execute VBIOS command table for DAC!\n",
1076 __func__);
1077 BREAK_TO_DEBUGGER();
1078 return;
1079 }
1080 }
1081
1082 /* The code below is only applicable to encoders with a digital transmitter. */
1083 if (enc110->base.transmitter == TRANSMITTER_UNKNOWN)
1084 return;
1085
1086 if (enc110->base.connector.id == CONNECTOR_ID_EDP)
1087 cntl.signal = SIGNAL_TYPE_EDP;
1088
1089 result = link_transmitter_control(enc110, &cntl);
1090
1091 if (result != BP_RESULT_OK) {
1092 DC_LOG_ERROR("%s: Failed to execute VBIOS command table!\n",
1093 __func__);
1094 BREAK_TO_DEBUGGER();
1095 return;
1096 }
1097
1098 if (enc110->base.connector.id == CONNECTOR_ID_LVDS) {
1099 cntl.action = TRANSMITTER_CONTROL_BACKLIGHT_BRIGHTNESS;
1100
1101 result = link_transmitter_control(enc110, &cntl);
1102
1103 ASSERT(result == BP_RESULT_OK);
1104
1105 }
1106
1107 if (enc110->aux_regs)
1108 aux_initialize(enc110);
1109
1110 /* reinitialize HPD.
1111 * hpd_initialize() will pass DIG_FE id to HW context.
1112 * All other routine within HW context will use fe_engine_offset
1113 * as DIG_FE id even caller pass DIG_FE id.
1114 * So this routine must be called first. */
1115 hpd_initialize(enc110);
1116}
1117
1118void dce110_link_encoder_destroy(struct link_encoder **enc)
1119{
1120 if ((*enc)->hpd_gpio) {
1121 dal_gpio_destroy_irq(&(*enc)->hpd_gpio);
1122 (*enc)->hpd_gpio = NULL;
1123 }
1124
1125 kfree(TO_DCE110_LINK_ENC(*enc));
1126 *enc = NULL;
1127}
1128
1129void dce110_link_encoder_setup(
1130 struct link_encoder *enc,
1131 enum signal_type signal)
1132{
1133 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
1134
1135 switch (signal) {
1136 case SIGNAL_TYPE_EDP:
1137 case SIGNAL_TYPE_DISPLAY_PORT:
1138 /* DP SST */
1139 REG_UPDATE(DIG_BE_CNTL, DIG_MODE, 0);
1140 break;
1141 case SIGNAL_TYPE_LVDS:
1142 /* LVDS */
1143 REG_UPDATE(DIG_BE_CNTL, DIG_MODE, 1);
1144 break;
1145 case SIGNAL_TYPE_DVI_SINGLE_LINK:
1146 case SIGNAL_TYPE_DVI_DUAL_LINK:
1147 /* TMDS-DVI */
1148 REG_UPDATE(DIG_BE_CNTL, DIG_MODE, 2);
1149 break;
1150 case SIGNAL_TYPE_HDMI_TYPE_A:
1151 /* TMDS-HDMI */
1152 REG_UPDATE(DIG_BE_CNTL, DIG_MODE, 3);
1153 break;
1154 case SIGNAL_TYPE_DISPLAY_PORT_MST:
1155 /* DP MST */
1156 REG_UPDATE(DIG_BE_CNTL, DIG_MODE, 5);
1157 break;
1158 case SIGNAL_TYPE_RGB:
1159 break;
1160 default:
1161 ASSERT_CRITICAL(false);
1162 /* invalid mode ! */
1163 break;
1164 }
1165
1166}
1167
1168/* TODO: still need depth or just pass in adjusted pixel clock? */
1169void dce110_link_encoder_enable_tmds_output(
1170 struct link_encoder *enc,
1171 enum clock_source_id clock_source,
1172 enum dc_color_depth color_depth,
1173 enum signal_type signal,
1174 uint32_t pixel_clock)
1175{
1176 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
1177 struct bp_transmitter_control cntl = { 0 };
1178 enum bp_result result;
1179
1180 /* Enable the PHY */
1181 cntl.connector_obj_id = enc110->base.connector;
1182 cntl.action = TRANSMITTER_CONTROL_ENABLE;
1183 cntl.engine_id = enc->preferred_engine;
1184 cntl.transmitter = enc110->base.transmitter;
1185 cntl.pll_id = clock_source;
1186 cntl.signal = signal;
1187 if (cntl.signal == SIGNAL_TYPE_DVI_DUAL_LINK)
1188 cntl.lanes_number = 8;
1189 else
1190 cntl.lanes_number = 4;
1191
1192 cntl.hpd_sel = enc110->base.hpd_source;
1193
1194 cntl.pixel_clock = pixel_clock;
1195 cntl.color_depth = color_depth;
1196
1197 result = link_transmitter_control(enc110, &cntl);
1198
1199 if (result != BP_RESULT_OK) {
1200 DC_LOG_ERROR("%s: Failed to execute VBIOS command table!\n",
1201 __func__);
1202 BREAK_TO_DEBUGGER();
1203 }
1204}
1205
1206/* TODO: still need depth or just pass in adjusted pixel clock? */
1207void dce110_link_encoder_enable_lvds_output(
1208 struct link_encoder *enc,
1209 enum clock_source_id clock_source,
1210 uint32_t pixel_clock)
1211{
1212 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
1213 struct bp_transmitter_control cntl = { 0 };
1214 enum bp_result result;
1215
1216 /* Enable the PHY */
1217 cntl.connector_obj_id = enc110->base.connector;
1218 cntl.action = TRANSMITTER_CONTROL_ENABLE;
1219 cntl.engine_id = enc->preferred_engine;
1220 cntl.transmitter = enc110->base.transmitter;
1221 cntl.pll_id = clock_source;
1222 cntl.signal = SIGNAL_TYPE_LVDS;
1223 cntl.lanes_number = 4;
1224
1225 cntl.hpd_sel = enc110->base.hpd_source;
1226
1227 cntl.pixel_clock = pixel_clock;
1228
1229 result = link_transmitter_control(enc110, &cntl);
1230
1231 if (result != BP_RESULT_OK) {
1232 DC_LOG_ERROR("%s: Failed to execute VBIOS command table!\n",
1233 __func__);
1234 BREAK_TO_DEBUGGER();
1235 }
1236}
1237
1238void dce110_link_encoder_enable_analog_output(
1239 struct link_encoder *enc,
1240 uint32_t pixel_clock)
1241{
1242 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
1243 enum bp_result result;
1244
1245 result = link_dac_encoder_control(enc110, ENCODER_CONTROL_ENABLE, pixel_clock);
1246
1247 if (result != BP_RESULT_OK) {
1248 DC_LOG_ERROR("%s: Failed to execute VBIOS command table!\n",
1249 __func__);
1250 BREAK_TO_DEBUGGER();
1251 }
1252}
1253
1254/* enables DP PHY output */
1255void dce110_link_encoder_enable_dp_output(
1256 struct link_encoder *enc,
1257 const struct dc_link_settings *link_settings,
1258 enum clock_source_id clock_source)
1259{
1260 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
1261 struct bp_transmitter_control cntl = { 0 };
1262 enum bp_result result;
1263
1264 /* Enable the PHY */
1265
1266 /* number_of_lanes is used for pixel clock adjust,
1267 * but it's not passed to asic_control.
1268 * We need to set number of lanes manually.
1269 */
1270 configure_encoder(enc110, link_settings);
1271 cntl.connector_obj_id = enc110->base.connector;
1272 cntl.action = TRANSMITTER_CONTROL_ENABLE;
1273 cntl.engine_id = enc->preferred_engine;
1274 cntl.transmitter = enc110->base.transmitter;
1275 cntl.pll_id = clock_source;
1276 cntl.signal = SIGNAL_TYPE_DISPLAY_PORT;
1277 cntl.lanes_number = link_settings->lane_count;
1278 cntl.hpd_sel = enc110->base.hpd_source;
1279 cntl.pixel_clock = link_settings->link_rate
1280 * LINK_RATE_REF_FREQ_IN_KHZ;
1281 /* TODO: check if undefined works */
1282 cntl.color_depth = COLOR_DEPTH_UNDEFINED;
1283
1284 result = link_transmitter_control(enc110, &cntl);
1285
1286 if (result != BP_RESULT_OK) {
1287 DC_LOG_ERROR("%s: Failed to execute VBIOS command table!\n",
1288 __func__);
1289 BREAK_TO_DEBUGGER();
1290 }
1291}
1292
1293/* enables DP PHY output in MST mode */
1294void dce110_link_encoder_enable_dp_mst_output(
1295 struct link_encoder *enc,
1296 const struct dc_link_settings *link_settings,
1297 enum clock_source_id clock_source)
1298{
1299 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
1300 struct bp_transmitter_control cntl = { 0 };
1301 enum bp_result result;
1302
1303 /* Enable the PHY */
1304
1305 /* number_of_lanes is used for pixel clock adjust,
1306 * but it's not passed to asic_control.
1307 * We need to set number of lanes manually.
1308 */
1309 configure_encoder(enc110, link_settings);
1310
1311 cntl.action = TRANSMITTER_CONTROL_ENABLE;
1312 cntl.engine_id = ENGINE_ID_UNKNOWN;
1313 cntl.transmitter = enc110->base.transmitter;
1314 cntl.pll_id = clock_source;
1315 cntl.signal = SIGNAL_TYPE_DISPLAY_PORT_MST;
1316 cntl.lanes_number = link_settings->lane_count;
1317 cntl.hpd_sel = enc110->base.hpd_source;
1318 cntl.pixel_clock = link_settings->link_rate
1319 * LINK_RATE_REF_FREQ_IN_KHZ;
1320 /* TODO: check if undefined works */
1321 cntl.color_depth = COLOR_DEPTH_UNDEFINED;
1322
1323 result = link_transmitter_control(enc110, &cntl);
1324
1325 if (result != BP_RESULT_OK) {
1326 DC_LOG_ERROR("%s: Failed to execute VBIOS command table!\n",
1327 __func__);
1328 BREAK_TO_DEBUGGER();
1329 }
1330}
1331
1332#if defined(CONFIG_DRM_AMD_DC_SI)
1333/* enables DP PHY output */
1334static void dce60_link_encoder_enable_dp_output(
1335 struct link_encoder *enc,
1336 const struct dc_link_settings *link_settings,
1337 enum clock_source_id clock_source)
1338{
1339 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
1340 struct bp_transmitter_control cntl = { 0 };
1341 enum bp_result result;
1342
1343 /* Enable the PHY */
1344
1345 /* number_of_lanes is used for pixel clock adjust,
1346 * but it's not passed to asic_control.
1347 * We need to set number of lanes manually.
1348 */
1349 dce60_configure_encoder(enc110, link_settings);
1350 cntl.connector_obj_id = enc110->base.connector;
1351 cntl.action = TRANSMITTER_CONTROL_ENABLE;
1352 cntl.engine_id = enc->preferred_engine;
1353 cntl.transmitter = enc110->base.transmitter;
1354 cntl.pll_id = clock_source;
1355 cntl.signal = SIGNAL_TYPE_DISPLAY_PORT;
1356 cntl.lanes_number = link_settings->lane_count;
1357 cntl.hpd_sel = enc110->base.hpd_source;
1358 cntl.pixel_clock = link_settings->link_rate
1359 * LINK_RATE_REF_FREQ_IN_KHZ;
1360 /* TODO: check if undefined works */
1361 cntl.color_depth = COLOR_DEPTH_UNDEFINED;
1362
1363 result = link_transmitter_control(enc110, &cntl);
1364
1365 if (result != BP_RESULT_OK) {
1366 DC_LOG_ERROR("%s: Failed to execute VBIOS command table!\n",
1367 __func__);
1368 BREAK_TO_DEBUGGER();
1369 }
1370}
1371
1372/* enables DP PHY output in MST mode */
1373static void dce60_link_encoder_enable_dp_mst_output(
1374 struct link_encoder *enc,
1375 const struct dc_link_settings *link_settings,
1376 enum clock_source_id clock_source)
1377{
1378 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
1379 struct bp_transmitter_control cntl = { 0 };
1380 enum bp_result result;
1381
1382 /* Enable the PHY */
1383
1384 /* number_of_lanes is used for pixel clock adjust,
1385 * but it's not passed to asic_control.
1386 * We need to set number of lanes manually.
1387 */
1388 dce60_configure_encoder(enc110, link_settings);
1389
1390 cntl.action = TRANSMITTER_CONTROL_ENABLE;
1391 cntl.engine_id = ENGINE_ID_UNKNOWN;
1392 cntl.transmitter = enc110->base.transmitter;
1393 cntl.pll_id = clock_source;
1394 cntl.signal = SIGNAL_TYPE_DISPLAY_PORT_MST;
1395 cntl.lanes_number = link_settings->lane_count;
1396 cntl.hpd_sel = enc110->base.hpd_source;
1397 cntl.pixel_clock = link_settings->link_rate
1398 * LINK_RATE_REF_FREQ_IN_KHZ;
1399 /* TODO: check if undefined works */
1400 cntl.color_depth = COLOR_DEPTH_UNDEFINED;
1401
1402 result = link_transmitter_control(enc110, &cntl);
1403
1404 if (result != BP_RESULT_OK) {
1405 DC_LOG_ERROR("%s: Failed to execute VBIOS command table!\n",
1406 __func__);
1407 BREAK_TO_DEBUGGER();
1408 }
1409}
1410#endif
1411
1412/*
1413 * @brief
1414 * Disable transmitter and its encoder
1415 */
1416void dce110_link_encoder_disable_output(
1417 struct link_encoder *enc,
1418 enum signal_type signal)
1419{
1420 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
1421 struct bp_transmitter_control cntl = { 0 };
1422 enum bp_result result;
1423
1424 if (enc->analog_engine != ENGINE_ID_UNKNOWN)
1425 link_dac_encoder_control(enc110, ENCODER_CONTROL_DISABLE, 0);
1426
1427 /* The code below only applies to connectors that support digital signals. */
1428 if (enc->transmitter == TRANSMITTER_UNKNOWN)
1429 return;
1430
1431 if (!dce110_is_dig_enabled(enc)) {
1432 /* OF_SKIP_POWER_DOWN_INACTIVE_ENCODER */
1433 return;
1434 }
1435 /* Power-down RX and disable GPU PHY should be paired.
1436 * Disabling PHY without powering down RX may cause
1437 * symbol lock loss, on which we will get DP Sink interrupt. */
1438
1439 /* There is a case for the DP active dongles
1440 * where we want to disable the PHY but keep RX powered,
1441 * for those we need to ignore DP Sink interrupt
1442 * by checking lane count that has been set
1443 * on the last do_enable_output(). */
1444
1445 /* disable transmitter */
1446 cntl.action = TRANSMITTER_CONTROL_DISABLE;
1447 cntl.transmitter = enc110->base.transmitter;
1448 cntl.hpd_sel = enc110->base.hpd_source;
1449 cntl.signal = signal;
1450 cntl.connector_obj_id = enc110->base.connector;
1451
1452 result = link_transmitter_control(enc110, &cntl);
1453
1454 if (result != BP_RESULT_OK) {
1455 DC_LOG_ERROR("%s: Failed to execute VBIOS command table!\n",
1456 __func__);
1457 BREAK_TO_DEBUGGER();
1458 return;
1459 }
1460
1461 /* disable encoder */
1462 if (dc_is_dp_signal(signal))
1463 link_encoder_disable(enc110);
1464}
1465
1466void dce110_link_encoder_dp_set_lane_settings(
1467 struct link_encoder *enc,
1468 const struct dc_link_settings *link_settings,
1469 const struct dc_lane_settings lane_settings[LANE_COUNT_DP_MAX])
1470{
1471 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
1472 union dpcd_training_lane_set training_lane_set = { { 0 } };
1473 int32_t lane = 0;
1474 struct bp_transmitter_control cntl = { 0 };
1475
1476 if (!link_settings) {
1477 BREAK_TO_DEBUGGER();
1478 return;
1479 }
1480
1481 cntl.action = TRANSMITTER_CONTROL_SET_VOLTAGE_AND_PREEMPASIS;
1482 cntl.transmitter = enc110->base.transmitter;
1483 cntl.connector_obj_id = enc110->base.connector;
1484 cntl.lanes_number = link_settings->lane_count;
1485 cntl.hpd_sel = enc110->base.hpd_source;
1486 cntl.pixel_clock = link_settings->link_rate *
1487 LINK_RATE_REF_FREQ_IN_KHZ;
1488
1489 for (lane = 0; lane < link_settings->lane_count; lane++) {
1490 /* translate lane settings */
1491
1492 training_lane_set.bits.VOLTAGE_SWING_SET =
1493 lane_settings[lane].VOLTAGE_SWING;
1494 training_lane_set.bits.PRE_EMPHASIS_SET =
1495 lane_settings[lane].PRE_EMPHASIS;
1496
1497 /* post cursor 2 setting only applies to HBR2 link rate */
1498 if (link_settings->link_rate == LINK_RATE_HIGH2) {
1499 /* this is passed to VBIOS
1500 * to program post cursor 2 level */
1501
1502 training_lane_set.bits.POST_CURSOR2_SET =
1503 lane_settings[lane].POST_CURSOR2;
1504 }
1505
1506 cntl.lane_select = lane;
1507 cntl.lane_settings = training_lane_set.raw;
1508
1509 /* call VBIOS table to set voltage swing and pre-emphasis */
1510 if (link_transmitter_control(enc110, &cntl) != BP_RESULT_OK) {
1511 DC_LOG_ERROR("%s: Failed to execute VBIOS command table!\n", __func__);
1512 BREAK_TO_DEBUGGER();
1513 }
1514 }
1515}
1516
1517/* set DP PHY test and training patterns */
1518void dce110_link_encoder_dp_set_phy_pattern(
1519 struct link_encoder *enc,
1520 const struct encoder_set_dp_phy_pattern_param *param)
1521{
1522 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
1523
1524 switch (param->dp_phy_pattern) {
1525 case DP_TEST_PATTERN_TRAINING_PATTERN1:
1526 dce110_link_encoder_set_dp_phy_pattern_training_pattern(enc, 0);
1527 break;
1528 case DP_TEST_PATTERN_TRAINING_PATTERN2:
1529 dce110_link_encoder_set_dp_phy_pattern_training_pattern(enc, 1);
1530 break;
1531 case DP_TEST_PATTERN_TRAINING_PATTERN3:
1532 dce110_link_encoder_set_dp_phy_pattern_training_pattern(enc, 2);
1533 break;
1534 case DP_TEST_PATTERN_TRAINING_PATTERN4:
1535 dce110_link_encoder_set_dp_phy_pattern_training_pattern(enc, 3);
1536 break;
1537 case DP_TEST_PATTERN_D102:
1538 set_dp_phy_pattern_d102(enc110);
1539 break;
1540 case DP_TEST_PATTERN_SYMBOL_ERROR:
1541 set_dp_phy_pattern_symbol_error(enc110);
1542 break;
1543 case DP_TEST_PATTERN_PRBS7:
1544 set_dp_phy_pattern_prbs7(enc110);
1545 break;
1546 case DP_TEST_PATTERN_80BIT_CUSTOM:
1547 set_dp_phy_pattern_80bit_custom(
1548 enc110, param->custom_pattern);
1549 break;
1550 case DP_TEST_PATTERN_CP2520_1:
1551 set_dp_phy_pattern_hbr2_compliance_cp2520_2(enc110, 1);
1552 break;
1553 case DP_TEST_PATTERN_CP2520_2:
1554 set_dp_phy_pattern_hbr2_compliance_cp2520_2(enc110, 2);
1555 break;
1556 case DP_TEST_PATTERN_CP2520_3:
1557 set_dp_phy_pattern_hbr2_compliance_cp2520_2(enc110, 3);
1558 break;
1559 case DP_TEST_PATTERN_VIDEO_MODE: {
1560 set_dp_phy_pattern_passthrough_mode(
1561 enc110, param->dp_panel_mode);
1562 break;
1563 }
1564
1565 default:
1566 /* invalid phy pattern */
1567 ASSERT_CRITICAL(false);
1568 break;
1569 }
1570}
1571
1572#if defined(CONFIG_DRM_AMD_DC_SI)
1573/* set DP PHY test and training patterns */
1574static void dce60_link_encoder_dp_set_phy_pattern(
1575 struct link_encoder *enc,
1576 const struct encoder_set_dp_phy_pattern_param *param)
1577{
1578 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
1579
1580 switch (param->dp_phy_pattern) {
1581 case DP_TEST_PATTERN_TRAINING_PATTERN1:
1582 dce110_link_encoder_set_dp_phy_pattern_training_pattern(enc, 0);
1583 break;
1584 case DP_TEST_PATTERN_TRAINING_PATTERN2:
1585 dce110_link_encoder_set_dp_phy_pattern_training_pattern(enc, 1);
1586 break;
1587 case DP_TEST_PATTERN_TRAINING_PATTERN3:
1588 dce110_link_encoder_set_dp_phy_pattern_training_pattern(enc, 2);
1589 break;
1590 case DP_TEST_PATTERN_TRAINING_PATTERN4:
1591 dce110_link_encoder_set_dp_phy_pattern_training_pattern(enc, 3);
1592 break;
1593 case DP_TEST_PATTERN_D102:
1594 set_dp_phy_pattern_d102(enc110);
1595 break;
1596 case DP_TEST_PATTERN_SYMBOL_ERROR:
1597 set_dp_phy_pattern_symbol_error(enc110);
1598 break;
1599 case DP_TEST_PATTERN_PRBS7:
1600 set_dp_phy_pattern_prbs7(enc110);
1601 break;
1602 case DP_TEST_PATTERN_80BIT_CUSTOM:
1603 set_dp_phy_pattern_80bit_custom(
1604 enc110, param->custom_pattern);
1605 break;
1606 case DP_TEST_PATTERN_CP2520_1:
1607 dce60_set_dp_phy_pattern_hbr2_compliance_cp2520_2(enc110, 1);
1608 break;
1609 case DP_TEST_PATTERN_CP2520_2:
1610 dce60_set_dp_phy_pattern_hbr2_compliance_cp2520_2(enc110, 2);
1611 break;
1612 case DP_TEST_PATTERN_CP2520_3:
1613 dce60_set_dp_phy_pattern_hbr2_compliance_cp2520_2(enc110, 3);
1614 break;
1615 case DP_TEST_PATTERN_VIDEO_MODE: {
1616 dce60_set_dp_phy_pattern_passthrough_mode(
1617 enc110, param->dp_panel_mode);
1618 break;
1619 }
1620
1621 default:
1622 /* invalid phy pattern */
1623 ASSERT_CRITICAL(false);
1624 break;
1625 }
1626}
1627#endif
1628
1629static void fill_stream_allocation_row_info(
1630 const struct link_mst_stream_allocation *stream_allocation,
1631 uint32_t *src,
1632 uint32_t *slots)
1633{
1634 const struct stream_encoder *stream_enc = stream_allocation->stream_enc;
1635
1636 if (stream_enc) {
1637 *src = stream_enc->id;
1638 *slots = stream_allocation->slot_count;
1639 } else {
1640 *src = 0;
1641 *slots = 0;
1642 }
1643}
1644
1645/* programs DP MST VC payload allocation */
1646void dce110_link_encoder_update_mst_stream_allocation_table(
1647 struct link_encoder *enc,
1648 const struct link_mst_stream_allocation_table *table)
1649{
1650 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
1651 uint32_t value1 = 0;
1652 uint32_t value2 = 0;
1653 uint32_t slots = 0;
1654 uint32_t src = 0;
1655 uint32_t retries = 0;
1656
1657 /* For CZ, there are only 3 pipes. So Virtual channel is up 3.*/
1658
1659 /* --- Set MSE Stream Attribute -
1660 * Setup VC Payload Table on Tx Side,
1661 * Issue allocation change trigger
1662 * to commit payload on both tx and rx side */
1663
1664 /* we should clean-up table each time */
1665
1666 if (table->stream_count >= 1) {
1667 fill_stream_allocation_row_info(
1668 &table->stream_allocations[0],
1669 &src,
1670 &slots);
1671 } else {
1672 src = 0;
1673 slots = 0;
1674 }
1675
1676 REG_UPDATE_2(DP_MSE_SAT0,
1677 DP_MSE_SAT_SRC0, src,
1678 DP_MSE_SAT_SLOT_COUNT0, slots);
1679
1680 if (table->stream_count >= 2) {
1681 fill_stream_allocation_row_info(
1682 &table->stream_allocations[1],
1683 &src,
1684 &slots);
1685 } else {
1686 src = 0;
1687 slots = 0;
1688 }
1689
1690 REG_UPDATE_2(DP_MSE_SAT0,
1691 DP_MSE_SAT_SRC1, src,
1692 DP_MSE_SAT_SLOT_COUNT1, slots);
1693
1694 if (table->stream_count >= 3) {
1695 fill_stream_allocation_row_info(
1696 &table->stream_allocations[2],
1697 &src,
1698 &slots);
1699 } else {
1700 src = 0;
1701 slots = 0;
1702 }
1703
1704 REG_UPDATE_2(DP_MSE_SAT1,
1705 DP_MSE_SAT_SRC2, src,
1706 DP_MSE_SAT_SLOT_COUNT2, slots);
1707
1708 if (table->stream_count >= 4) {
1709 fill_stream_allocation_row_info(
1710 &table->stream_allocations[3],
1711 &src,
1712 &slots);
1713 } else {
1714 src = 0;
1715 slots = 0;
1716 }
1717
1718 REG_UPDATE_2(DP_MSE_SAT1,
1719 DP_MSE_SAT_SRC3, src,
1720 DP_MSE_SAT_SLOT_COUNT3, slots);
1721
1722 /* --- wait for transaction finish */
1723
1724 /* send allocation change trigger (ACT) ?
1725 * this step first sends the ACT,
1726 * then double buffers the SAT into the hardware
1727 * making the new allocation active on the DP MST mode link */
1728
1729
1730 /* DP_MSE_SAT_UPDATE:
1731 * 0 - No Action
1732 * 1 - Update SAT with trigger
1733 * 2 - Update SAT without trigger */
1734
1735 REG_UPDATE(DP_MSE_SAT_UPDATE,
1736 DP_MSE_SAT_UPDATE, 1);
1737
1738 /* wait for update to complete
1739 * (i.e. DP_MSE_SAT_UPDATE field is reset to 0)
1740 * then wait for the transmission
1741 * of at least 16 MTP headers on immediate local link.
1742 * i.e. DP_MSE_16_MTP_KEEPOUT field (read only) is reset to 0
1743 * a value of 1 indicates that DP MST mode
1744 * is in the 16 MTP keepout region after a VC has been added.
1745 * MST stream bandwidth (VC rate) can be configured
1746 * after this bit is cleared */
1747
1748 do {
1749 udelay(10);
1750
1751 REG_READ(DP_MSE_SAT_UPDATE);
1752
1753 REG_GET(DP_MSE_SAT_UPDATE,
1754 DP_MSE_SAT_UPDATE, &value1);
1755
1756 REG_GET(DP_MSE_SAT_UPDATE,
1757 DP_MSE_16_MTP_KEEPOUT, &value2);
1758
1759 /* bit field DP_MSE_SAT_UPDATE is set to 1 already */
1760 if (!value1 && !value2)
1761 break;
1762 ++retries;
1763 } while (retries < DP_MST_UPDATE_MAX_RETRY);
1764}
1765
1766void dce110_link_encoder_connect_dig_be_to_fe(
1767 struct link_encoder *enc,
1768 enum engine_id engine,
1769 bool connect)
1770{
1771 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
1772 uint32_t field;
1773
1774 if (engine != ENGINE_ID_UNKNOWN) {
1775
1776 REG_GET(DIG_BE_CNTL, DIG_FE_SOURCE_SELECT, &field);
1777
1778 if (connect)
1779 field |= get_frontend_source(engine);
1780 else
1781 field &= ~get_frontend_source(engine);
1782
1783 REG_UPDATE(DIG_BE_CNTL, DIG_FE_SOURCE_SELECT, field);
1784 }
1785}
1786
1787void dce110_link_encoder_enable_hpd(struct link_encoder *enc)
1788{
1789 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
1790 struct dc_context *ctx = enc110->base.ctx;
1791 uint32_t addr = HPD_REG(DC_HPD_CONTROL);
1792 uint32_t hpd_enable = 0;
1793 uint32_t value = dm_read_reg(ctx, addr);
1794
1795 hpd_enable = get_reg_field_value(hpd_enable, DC_HPD_CONTROL, DC_HPD_EN);
1796
1797 if (hpd_enable == 0)
1798 set_reg_field_value(value, 1, DC_HPD_CONTROL, DC_HPD_EN);
1799}
1800
1801void dce110_link_encoder_disable_hpd(struct link_encoder *enc)
1802{
1803 struct dce110_link_encoder *enc110 = TO_DCE110_LINK_ENC(enc);
1804 struct dc_context *ctx = enc110->base.ctx;
1805 uint32_t addr = HPD_REG(DC_HPD_CONTROL);
1806 uint32_t value = dm_read_reg(ctx, addr);
1807
1808 set_reg_field_value(value, 0, DC_HPD_CONTROL, DC_HPD_EN);
1809}
1810
1811void dce110_link_encoder_get_max_link_cap(struct link_encoder *enc,
1812 struct dc_link_settings *link_settings)
1813{
1814 /* Set Default link settings */
1815 struct dc_link_settings max_link_cap = {LANE_COUNT_FOUR, LINK_RATE_HIGH,
1816 LINK_SPREAD_05_DOWNSPREAD_30KHZ, false, 0};
1817
1818 /* Higher link settings based on feature supported */
1819 if (enc->features.flags.bits.IS_HBR2_CAPABLE)
1820 max_link_cap.link_rate = LINK_RATE_HIGH2;
1821
1822 if (enc->features.flags.bits.IS_HBR3_CAPABLE)
1823 max_link_cap.link_rate = LINK_RATE_HIGH3;
1824
1825 *link_settings = max_link_cap;
1826}
1827
1828bool dce110_get_hpd_state(struct link_encoder *enc)
1829{
1830 uint32_t state = 0;
1831
1832 if (!enc->hpd_gpio)
1833 return false;
1834
1835 dal_gpio_lock_pin(enc->hpd_gpio);
1836 dal_gpio_get_value(enc->hpd_gpio, &state);
1837 dal_gpio_unlock_pin(enc->hpd_gpio);
1838
1839 return state;
1840}
1841
1842bool dce110_program_hpd_filter(struct link_encoder *enc, int delay_on_connect_in_ms, int delay_on_disconnect_in_ms)
1843{
1844 /* Setup HPD filtering */
1845 if (enc->hpd_gpio && dal_gpio_lock_pin(enc->hpd_gpio) == GPIO_RESULT_OK) {
1846 struct gpio_hpd_config config;
1847
1848 config.delay_on_connect = delay_on_connect_in_ms;
1849 config.delay_on_disconnect = delay_on_disconnect_in_ms;
1850
1851 dal_irq_setup_hpd_filter(enc->hpd_gpio, &config);
1852
1853 dal_gpio_unlock_pin(enc->hpd_gpio);
1854
1855 return true;
1856 } else {
1857 ASSERT(0);
1858 return false;
1859 }
1860}
1861
1862#if defined(CONFIG_DRM_AMD_DC_SI)
1863static const struct link_encoder_funcs dce60_lnk_enc_funcs = {
1864 .validate_output_with_stream =
1865 dce110_link_encoder_validate_output_with_stream,
1866 .hw_init = dce110_link_encoder_hw_init,
1867 .setup = dce110_link_encoder_setup,
1868 .enable_tmds_output = dce110_link_encoder_enable_tmds_output,
1869 .enable_dp_output = dce60_link_encoder_enable_dp_output,
1870 .enable_dp_mst_output = dce60_link_encoder_enable_dp_mst_output,
1871 .enable_lvds_output = dce110_link_encoder_enable_lvds_output,
1872 .enable_analog_output = dce110_link_encoder_enable_analog_output,
1873 .disable_output = dce110_link_encoder_disable_output,
1874 .dp_set_lane_settings = dce110_link_encoder_dp_set_lane_settings,
1875 .dp_set_phy_pattern = dce60_link_encoder_dp_set_phy_pattern,
1876 .update_mst_stream_allocation_table =
1877 dce110_link_encoder_update_mst_stream_allocation_table,
1878 .psr_program_dp_dphy_fast_training =
1879 dce110_psr_program_dp_dphy_fast_training,
1880 .psr_program_secondary_packet = dce110_psr_program_secondary_packet,
1881 .connect_dig_be_to_fe = dce110_link_encoder_connect_dig_be_to_fe,
1882 .enable_hpd = dce110_link_encoder_enable_hpd,
1883 .disable_hpd = dce110_link_encoder_disable_hpd,
1884 .is_dig_enabled = dce110_is_dig_enabled,
1885 .destroy = dce110_link_encoder_destroy,
1886 .get_max_link_cap = dce110_link_encoder_get_max_link_cap,
1887 .get_dig_frontend = dce110_get_dig_frontend,
1888 .get_hpd_state = dce110_get_hpd_state,
1889 .program_hpd_filter = dce110_program_hpd_filter,
1890};
1891
1892static const struct link_encoder_funcs dce60_lnk_enc_funcs_no_hpd = {
1893 .validate_output_with_stream =
1894 dce110_link_encoder_validate_output_with_stream,
1895 .hw_init = dce110_link_encoder_hw_init,
1896 .setup = dce110_link_encoder_setup,
1897 .enable_tmds_output = dce110_link_encoder_enable_tmds_output,
1898 .enable_dp_output = dce60_link_encoder_enable_dp_output,
1899 .enable_dp_mst_output = dce60_link_encoder_enable_dp_mst_output,
1900 .enable_lvds_output = dce110_link_encoder_enable_lvds_output,
1901 .enable_analog_output = dce110_link_encoder_enable_analog_output,
1902 .disable_output = dce110_link_encoder_disable_output,
1903 .dp_set_lane_settings = dce110_link_encoder_dp_set_lane_settings,
1904 .dp_set_phy_pattern = dce60_link_encoder_dp_set_phy_pattern,
1905 .update_mst_stream_allocation_table =
1906 dce110_link_encoder_update_mst_stream_allocation_table,
1907 .psr_program_dp_dphy_fast_training =
1908 dce110_psr_program_dp_dphy_fast_training,
1909 .psr_program_secondary_packet = dce110_psr_program_secondary_packet,
1910 .connect_dig_be_to_fe = dce110_link_encoder_connect_dig_be_to_fe,
1911 .is_dig_enabled = dce110_is_dig_enabled,
1912 .destroy = dce110_link_encoder_destroy,
1913 .get_max_link_cap = dce110_link_encoder_get_max_link_cap,
1914 .get_dig_frontend = dce110_get_dig_frontend,
1915 .get_hpd_state = dce110_get_hpd_state,
1916 .program_hpd_filter = dce110_program_hpd_filter,
1917};
1918
1919void dce60_link_encoder_construct(
1920 struct dce110_link_encoder *enc110,
1921 const struct encoder_init_data *init_data,
1922 const struct encoder_feature_support *enc_features,
1923 const struct dce110_link_enc_registers *link_regs,
1924 const struct dce110_link_enc_aux_registers *aux_regs,
1925 const struct dce110_link_enc_hpd_registers *hpd_regs)
1926{
1927 struct bp_encoder_cap_info bp_cap_info = {0};
1928 const struct dc_vbios_funcs *bp_funcs = init_data->ctx->dc_bios->funcs;
1929 enum bp_result result = BP_RESULT_OK;
1930
1931 if (hpd_regs)
1932 enc110->base.funcs = &dce60_lnk_enc_funcs;
1933 else
1934 enc110->base.funcs = &dce60_lnk_enc_funcs_no_hpd;
1935 enc110->base.ctx = init_data->ctx;
1936 enc110->base.id = init_data->encoder;
1937 enc110->base.analog_id = init_data->analog_encoder;
1938
1939 enc110->base.hpd_gpio = init_data->hpd_gpio;
1940 enc110->base.hpd_source = init_data->hpd_source;
1941 enc110->base.connector = init_data->connector;
1942
1943 enc110->base.preferred_engine = ENGINE_ID_UNKNOWN;
1944 enc110->base.analog_engine = init_data->analog_engine;
1945
1946 enc110->base.features = *enc_features;
1947
1948 enc110->base.transmitter = init_data->transmitter;
1949
1950 /* set the flag to indicate whether driver poll the I2C data pin
1951 * while doing the DP sink detect
1952 */
1953
1954/* if (dal_adapter_service_is_feature_supported(as,
1955 FEATURE_DP_SINK_DETECT_POLL_DATA_PIN))
1956 enc110->base.features.flags.bits.
1957 DP_SINK_DETECT_POLL_DATA_PIN = true;*/
1958
1959 enc110->base.output_signals =
1960 SIGNAL_TYPE_DVI_SINGLE_LINK |
1961 SIGNAL_TYPE_DVI_DUAL_LINK |
1962 SIGNAL_TYPE_LVDS |
1963 SIGNAL_TYPE_DISPLAY_PORT |
1964 SIGNAL_TYPE_DISPLAY_PORT_MST |
1965 SIGNAL_TYPE_EDP |
1966 SIGNAL_TYPE_HDMI_TYPE_A;
1967
1968 if ((enc110->base.connector.id == CONNECTOR_ID_DUAL_LINK_DVII ||
1969 enc110->base.connector.id == CONNECTOR_ID_SINGLE_LINK_DVII) &&
1970 enc110->base.analog_engine != ENGINE_ID_UNKNOWN)
1971 enc110->base.output_signals |= SIGNAL_TYPE_RGB;
1972
1973 /* For DCE 8.0 and 8.1, by design, UNIPHY is hardwired to DIG_BE.
1974 * SW always assign DIG_FE 1:1 mapped to DIG_FE for non-MST UNIPHY.
1975 * SW assign DIG_FE to non-MST UNIPHY first and MST last. So prefer
1976 * DIG is per UNIPHY and used by SST DP, eDP, HDMI, DVI and LVDS.
1977 * Prefer DIG assignment is decided by board design.
1978 * For DCE 8.0, there are only max 6 UNIPHYs, we assume board design
1979 * and VBIOS will filter out 7 UNIPHY for DCE 8.0.
1980 * By this, adding DIGG should not hurt DCE 8.0.
1981 * This will let DCE 8.1 share DCE 8.0 as much as possible
1982 */
1983
1984 enc110->link_regs = link_regs;
1985 enc110->aux_regs = aux_regs;
1986 enc110->hpd_regs = hpd_regs;
1987
1988 switch (enc110->base.transmitter) {
1989 case TRANSMITTER_UNIPHY_A:
1990 enc110->base.preferred_engine = ENGINE_ID_DIGA;
1991 break;
1992 case TRANSMITTER_UNIPHY_B:
1993 enc110->base.preferred_engine = ENGINE_ID_DIGB;
1994 break;
1995 case TRANSMITTER_UNIPHY_C:
1996 enc110->base.preferred_engine = ENGINE_ID_DIGC;
1997 break;
1998 case TRANSMITTER_UNIPHY_D:
1999 enc110->base.preferred_engine = ENGINE_ID_DIGD;
2000 break;
2001 case TRANSMITTER_UNIPHY_E:
2002 enc110->base.preferred_engine = ENGINE_ID_DIGE;
2003 break;
2004 case TRANSMITTER_UNIPHY_F:
2005 enc110->base.preferred_engine = ENGINE_ID_DIGF;
2006 break;
2007 case TRANSMITTER_UNIPHY_G:
2008 enc110->base.preferred_engine = ENGINE_ID_DIGG;
2009 break;
2010 default:
2011 if (init_data->analog_engine != ENGINE_ID_UNKNOWN) {
2012 /* The connector is analog-only, ie. VGA */
2013 enc110->base.preferred_engine = init_data->analog_engine;
2014 enc110->base.output_signals = SIGNAL_TYPE_RGB;
2015 enc110->base.transmitter = TRANSMITTER_UNKNOWN;
2016 break;
2017 }
2018 ASSERT_CRITICAL(false);
2019 enc110->base.preferred_engine = ENGINE_ID_UNKNOWN;
2020 }
2021
2022 /* default to one to mirror Windows behavior */
2023 enc110->base.features.flags.bits.HDMI_6GB_EN = 1;
2024
2025 result = bp_funcs->get_encoder_cap_info(enc110->base.ctx->dc_bios,
2026 enc110->base.id, &bp_cap_info);
2027
2028 /* Override features with DCE-specific values */
2029 if (result == BP_RESULT_OK) {
2030 enc110->base.features.flags.bits.IS_HBR2_CAPABLE =
2031 bp_cap_info.DP_HBR2_EN;
2032 enc110->base.features.flags.bits.IS_HBR3_CAPABLE =
2033 bp_cap_info.DP_HBR3_EN;
2034 enc110->base.features.flags.bits.HDMI_6GB_EN = bp_cap_info.HDMI_6GB_EN;
2035 } else if (result != BP_RESULT_NORECORD) {
2036 DC_LOG_WARNING("%s: Failed to get encoder_cap_info from VBIOS with error code %d!\n",
2037 __func__,
2038 result);
2039 }
2040 if (enc110->base.ctx->dc->debug.hdmi20_disable) {
2041 enc110->base.features.flags.bits.HDMI_6GB_EN = 0;
2042 }
2043}
2044#endif