2 * Copyright © 2012 Intel Corporation
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:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
24 * Eugeni Dodonov <eugeni.dodonov@intel.com>
29 #include "intel_drv.h"
31 /* HDMI/DVI modes ignore everything but the last 2 items. So we share
32 * them for both DP and FDI transports, allowing those ports to
33 * automatically adapt to HDMI connections as well
35 static const u32 hsw_ddi_translations_dp[] = {
36 0x00FFFFFF, 0x0006000E,
37 0x00D75FFF, 0x0005000A,
38 0x00C30FFF, 0x00040006,
39 0x80AAAFFF, 0x000B0000,
40 0x00FFFFFF, 0x0005000A,
41 0x00D75FFF, 0x000C0004,
42 0x80C30FFF, 0x000B0000,
43 0x00FFFFFF, 0x00040006,
44 0x80D75FFF, 0x000B0000,
47 static const u32 hsw_ddi_translations_fdi[] = {
48 0x00FFFFFF, 0x0007000E,
49 0x00D75FFF, 0x000F000A,
50 0x00C30FFF, 0x00060006,
51 0x00AAAFFF, 0x001E0000,
52 0x00FFFFFF, 0x000F000A,
53 0x00D75FFF, 0x00160004,
54 0x00C30FFF, 0x001E0000,
55 0x00FFFFFF, 0x00060006,
56 0x00D75FFF, 0x001E0000,
59 static const u32 hsw_ddi_translations_hdmi[] = {
60 /* Idx NT mV diff T mV diff db */
61 0x00FFFFFF, 0x0006000E, /* 0: 400 400 0 */
62 0x00E79FFF, 0x000E000C, /* 1: 400 500 2 */
63 0x00D75FFF, 0x0005000A, /* 2: 400 600 3.5 */
64 0x00FFFFFF, 0x0005000A, /* 3: 600 600 0 */
65 0x00E79FFF, 0x001D0007, /* 4: 600 750 2 */
66 0x00D75FFF, 0x000C0004, /* 5: 600 900 3.5 */
67 0x00FFFFFF, 0x00040006, /* 6: 800 800 0 */
68 0x80E79FFF, 0x00030002, /* 7: 800 1000 2 */
69 0x00FFFFFF, 0x00140005, /* 8: 850 850 0 */
70 0x00FFFFFF, 0x000C0004, /* 9: 900 900 0 */
71 0x00FFFFFF, 0x001C0003, /* 10: 950 950 0 */
72 0x80FFFFFF, 0x00030002, /* 11: 1000 1000 0 */
75 static const u32 bdw_ddi_translations_edp[] = {
76 0x00FFFFFF, 0x00000012,
77 0x00EBAFFF, 0x00020011,
78 0x00C71FFF, 0x0006000F,
79 0x00AAAFFF, 0x000E000A,
80 0x00FFFFFF, 0x00020011,
81 0x00DB6FFF, 0x0005000F,
82 0x00BEEFFF, 0x000A000C,
83 0x00FFFFFF, 0x0005000F,
84 0x00DB6FFF, 0x000A000C,
87 static const u32 bdw_ddi_translations_dp[] = {
88 0x00FFFFFF, 0x0007000E,
89 0x00D75FFF, 0x000E000A,
90 0x00BEFFFF, 0x00140006,
91 0x80B2CFFF, 0x001B0002,
92 0x00FFFFFF, 0x000E000A,
93 0x00D75FFF, 0x00180004,
94 0x80CB2FFF, 0x001B0002,
95 0x00F7DFFF, 0x00180004,
96 0x80D75FFF, 0x001B0002,
99 static const u32 bdw_ddi_translations_fdi[] = {
100 0x00FFFFFF, 0x0001000E,
101 0x00D75FFF, 0x0004000A,
102 0x00C30FFF, 0x00070006,
103 0x00AAAFFF, 0x000C0000,
104 0x00FFFFFF, 0x0004000A,
105 0x00D75FFF, 0x00090004,
106 0x00C30FFF, 0x000C0000,
107 0x00FFFFFF, 0x00070006,
108 0x00D75FFF, 0x000C0000,
111 static const u32 bdw_ddi_translations_hdmi[] = {
112 /* Idx NT mV diff T mV diff db */
113 0x00FFFFFF, 0x0007000E, /* 0: 400 400 0 */
114 0x00D75FFF, 0x000E000A, /* 1: 400 600 3.5 */
115 0x00BEFFFF, 0x00140006, /* 2: 400 800 6 */
116 0x00FFFFFF, 0x0009000D, /* 3: 450 450 0 */
117 0x00FFFFFF, 0x000E000A, /* 4: 600 600 0 */
118 0x00D7FFFF, 0x00140006, /* 5: 600 800 2.5 */
119 0x80CB2FFF, 0x001B0002, /* 6: 600 1000 4.5 */
120 0x00FFFFFF, 0x00140006, /* 7: 800 800 0 */
121 0x80E79FFF, 0x001B0002, /* 8: 800 1000 2 */
122 0x80FFFFFF, 0x001B0002, /* 9: 1000 1000 0 */
125 enum port intel_ddi_get_encoder_port(struct intel_encoder *intel_encoder)
127 struct drm_encoder *encoder = &intel_encoder->base;
128 int type = intel_encoder->type;
130 if (type == INTEL_OUTPUT_DP_MST) {
131 struct intel_digital_port *intel_dig_port = enc_to_mst(encoder)->primary;
132 return intel_dig_port->port;
133 } else if (type == INTEL_OUTPUT_DISPLAYPORT || type == INTEL_OUTPUT_EDP ||
134 type == INTEL_OUTPUT_HDMI || type == INTEL_OUTPUT_UNKNOWN) {
135 struct intel_digital_port *intel_dig_port =
136 enc_to_dig_port(encoder);
137 return intel_dig_port->port;
139 } else if (type == INTEL_OUTPUT_ANALOG) {
143 DRM_ERROR("Invalid DDI encoder type %d\n", type);
149 * Starting with Haswell, DDI port buffers must be programmed with correct
150 * values in advance. The buffer values are different for FDI and DP modes,
151 * but the HDMI/DVI fields are shared among those. So we program the DDI
152 * in either FDI or DP modes only, as HDMI connections will work with both
155 static void intel_prepare_ddi_buffers(struct drm_device *dev, enum port port)
157 struct drm_i915_private *dev_priv = dev->dev_private;
159 int i, n_hdmi_entries, hdmi_800mV_0dB;
160 int hdmi_level = dev_priv->vbt.ddi_port_info[port].hdmi_level_shift;
161 const u32 *ddi_translations_fdi;
162 const u32 *ddi_translations_dp;
163 const u32 *ddi_translations_edp;
164 const u32 *ddi_translations_hdmi;
165 const u32 *ddi_translations;
167 if (IS_BROADWELL(dev)) {
168 ddi_translations_fdi = bdw_ddi_translations_fdi;
169 ddi_translations_dp = bdw_ddi_translations_dp;
170 ddi_translations_edp = bdw_ddi_translations_edp;
171 ddi_translations_hdmi = bdw_ddi_translations_hdmi;
172 n_hdmi_entries = ARRAY_SIZE(bdw_ddi_translations_hdmi) / 2;
174 } else if (IS_HASWELL(dev)) {
175 ddi_translations_fdi = hsw_ddi_translations_fdi;
176 ddi_translations_dp = hsw_ddi_translations_dp;
177 ddi_translations_edp = hsw_ddi_translations_dp;
178 ddi_translations_hdmi = hsw_ddi_translations_hdmi;
179 n_hdmi_entries = ARRAY_SIZE(hsw_ddi_translations_hdmi) / 2;
182 WARN(1, "ddi translation table missing\n");
183 ddi_translations_edp = bdw_ddi_translations_dp;
184 ddi_translations_fdi = bdw_ddi_translations_fdi;
185 ddi_translations_dp = bdw_ddi_translations_dp;
186 ddi_translations_hdmi = bdw_ddi_translations_hdmi;
187 n_hdmi_entries = ARRAY_SIZE(bdw_ddi_translations_hdmi) / 2;
193 ddi_translations = ddi_translations_edp;
197 ddi_translations = ddi_translations_dp;
200 if (intel_dp_is_edp(dev, PORT_D))
201 ddi_translations = ddi_translations_edp;
203 ddi_translations = ddi_translations_dp;
206 ddi_translations = ddi_translations_fdi;
212 for (i = 0, reg = DDI_BUF_TRANS(port);
213 i < ARRAY_SIZE(hsw_ddi_translations_fdi); i++) {
214 I915_WRITE(reg, ddi_translations[i]);
218 /* Choose a good default if VBT is badly populated */
219 if (hdmi_level == HDMI_LEVEL_SHIFT_UNKNOWN ||
220 hdmi_level >= n_hdmi_entries)
221 hdmi_level = hdmi_800mV_0dB;
223 /* Entry 9 is for HDMI: */
224 for (i = 0; i < 2; i++) {
225 I915_WRITE(reg, ddi_translations_hdmi[hdmi_level * 2 + i]);
230 /* Program DDI buffers translations for DP. By default, program ports A-D in DP
231 * mode and port E for FDI.
233 void intel_prepare_ddi(struct drm_device *dev)
240 for (port = PORT_A; port <= PORT_E; port++)
241 intel_prepare_ddi_buffers(dev, port);
244 static const long hsw_ddi_buf_ctl_values[] = {
245 DDI_BUF_EMP_400MV_0DB_HSW,
246 DDI_BUF_EMP_400MV_3_5DB_HSW,
247 DDI_BUF_EMP_400MV_6DB_HSW,
248 DDI_BUF_EMP_400MV_9_5DB_HSW,
249 DDI_BUF_EMP_600MV_0DB_HSW,
250 DDI_BUF_EMP_600MV_3_5DB_HSW,
251 DDI_BUF_EMP_600MV_6DB_HSW,
252 DDI_BUF_EMP_800MV_0DB_HSW,
253 DDI_BUF_EMP_800MV_3_5DB_HSW
256 static void intel_wait_ddi_buf_idle(struct drm_i915_private *dev_priv,
259 uint32_t reg = DDI_BUF_CTL(port);
262 for (i = 0; i < 8; i++) {
264 if (I915_READ(reg) & DDI_BUF_IS_IDLE)
267 DRM_ERROR("Timeout waiting for DDI BUF %c idle bit\n", port_name(port));
270 /* Starting with Haswell, different DDI ports can work in FDI mode for
271 * connection to the PCH-located connectors. For this, it is necessary to train
272 * both the DDI port and PCH receiver for the desired DDI buffer settings.
274 * The recommended port to work in FDI mode is DDI E, which we use here. Also,
275 * please note that when FDI mode is active on DDI E, it shares 2 lines with
276 * DDI A (which is used for eDP)
279 void hsw_fdi_link_train(struct drm_crtc *crtc)
281 struct drm_device *dev = crtc->dev;
282 struct drm_i915_private *dev_priv = dev->dev_private;
283 struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
284 u32 temp, i, rx_ctl_val;
286 /* Set the FDI_RX_MISC pwrdn lanes and the 2 workarounds listed at the
287 * mode set "sequence for CRT port" document:
288 * - TP1 to TP2 time with the default value
291 * WaFDIAutoLinkSetTimingOverrride:hsw
293 I915_WRITE(_FDI_RXA_MISC, FDI_RX_PWRDN_LANE1_VAL(2) |
294 FDI_RX_PWRDN_LANE0_VAL(2) |
295 FDI_RX_TP1_TO_TP2_48 | FDI_RX_FDI_DELAY_90);
297 /* Enable the PCH Receiver FDI PLL */
298 rx_ctl_val = dev_priv->fdi_rx_config | FDI_RX_ENHANCE_FRAME_ENABLE |
300 FDI_DP_PORT_WIDTH(intel_crtc->config.fdi_lanes);
301 I915_WRITE(_FDI_RXA_CTL, rx_ctl_val);
302 POSTING_READ(_FDI_RXA_CTL);
305 /* Switch from Rawclk to PCDclk */
306 rx_ctl_val |= FDI_PCDCLK;
307 I915_WRITE(_FDI_RXA_CTL, rx_ctl_val);
309 /* Configure Port Clock Select */
310 I915_WRITE(PORT_CLK_SEL(PORT_E), intel_crtc->config.ddi_pll_sel);
311 WARN_ON(intel_crtc->config.ddi_pll_sel != PORT_CLK_SEL_SPLL);
313 /* Start the training iterating through available voltages and emphasis,
314 * testing each value twice. */
315 for (i = 0; i < ARRAY_SIZE(hsw_ddi_buf_ctl_values) * 2; i++) {
316 /* Configure DP_TP_CTL with auto-training */
317 I915_WRITE(DP_TP_CTL(PORT_E),
318 DP_TP_CTL_FDI_AUTOTRAIN |
319 DP_TP_CTL_ENHANCED_FRAME_ENABLE |
320 DP_TP_CTL_LINK_TRAIN_PAT1 |
323 /* Configure and enable DDI_BUF_CTL for DDI E with next voltage.
324 * DDI E does not support port reversal, the functionality is
325 * achieved on the PCH side in FDI_RX_CTL, so no need to set the
326 * port reversal bit */
327 I915_WRITE(DDI_BUF_CTL(PORT_E),
329 ((intel_crtc->config.fdi_lanes - 1) << 1) |
330 hsw_ddi_buf_ctl_values[i / 2]);
331 POSTING_READ(DDI_BUF_CTL(PORT_E));
335 /* Program PCH FDI Receiver TU */
336 I915_WRITE(_FDI_RXA_TUSIZE1, TU_SIZE(64));
338 /* Enable PCH FDI Receiver with auto-training */
339 rx_ctl_val |= FDI_RX_ENABLE | FDI_LINK_TRAIN_AUTO;
340 I915_WRITE(_FDI_RXA_CTL, rx_ctl_val);
341 POSTING_READ(_FDI_RXA_CTL);
343 /* Wait for FDI receiver lane calibration */
346 /* Unset FDI_RX_MISC pwrdn lanes */
347 temp = I915_READ(_FDI_RXA_MISC);
348 temp &= ~(FDI_RX_PWRDN_LANE1_MASK | FDI_RX_PWRDN_LANE0_MASK);
349 I915_WRITE(_FDI_RXA_MISC, temp);
350 POSTING_READ(_FDI_RXA_MISC);
352 /* Wait for FDI auto training time */
355 temp = I915_READ(DP_TP_STATUS(PORT_E));
356 if (temp & DP_TP_STATUS_AUTOTRAIN_DONE) {
357 DRM_DEBUG_KMS("FDI link training done on step %d\n", i);
359 /* Enable normal pixel sending for FDI */
360 I915_WRITE(DP_TP_CTL(PORT_E),
361 DP_TP_CTL_FDI_AUTOTRAIN |
362 DP_TP_CTL_LINK_TRAIN_NORMAL |
363 DP_TP_CTL_ENHANCED_FRAME_ENABLE |
369 temp = I915_READ(DDI_BUF_CTL(PORT_E));
370 temp &= ~DDI_BUF_CTL_ENABLE;
371 I915_WRITE(DDI_BUF_CTL(PORT_E), temp);
372 POSTING_READ(DDI_BUF_CTL(PORT_E));
374 /* Disable DP_TP_CTL and FDI_RX_CTL and retry */
375 temp = I915_READ(DP_TP_CTL(PORT_E));
376 temp &= ~(DP_TP_CTL_ENABLE | DP_TP_CTL_LINK_TRAIN_MASK);
377 temp |= DP_TP_CTL_LINK_TRAIN_PAT1;
378 I915_WRITE(DP_TP_CTL(PORT_E), temp);
379 POSTING_READ(DP_TP_CTL(PORT_E));
381 intel_wait_ddi_buf_idle(dev_priv, PORT_E);
383 rx_ctl_val &= ~FDI_RX_ENABLE;
384 I915_WRITE(_FDI_RXA_CTL, rx_ctl_val);
385 POSTING_READ(_FDI_RXA_CTL);
387 /* Reset FDI_RX_MISC pwrdn lanes */
388 temp = I915_READ(_FDI_RXA_MISC);
389 temp &= ~(FDI_RX_PWRDN_LANE1_MASK | FDI_RX_PWRDN_LANE0_MASK);
390 temp |= FDI_RX_PWRDN_LANE1_VAL(2) | FDI_RX_PWRDN_LANE0_VAL(2);
391 I915_WRITE(_FDI_RXA_MISC, temp);
392 POSTING_READ(_FDI_RXA_MISC);
395 DRM_ERROR("FDI link training failed!\n");
398 void intel_ddi_init_dp_buf_reg(struct intel_encoder *encoder)
400 struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
401 struct intel_digital_port *intel_dig_port =
402 enc_to_dig_port(&encoder->base);
404 intel_dp->DP = intel_dig_port->saved_port_bits |
405 DDI_BUF_CTL_ENABLE | DDI_BUF_EMP_400MV_0DB_HSW;
406 intel_dp->DP |= DDI_PORT_WIDTH(intel_dp->lane_count);
410 static struct intel_encoder *
411 intel_ddi_get_crtc_encoder(struct drm_crtc *crtc)
413 struct drm_device *dev = crtc->dev;
414 struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
415 struct intel_encoder *intel_encoder, *ret = NULL;
416 int num_encoders = 0;
418 for_each_encoder_on_crtc(dev, crtc, intel_encoder) {
423 if (num_encoders != 1)
424 WARN(1, "%d encoders on crtc for pipe %c\n", num_encoders,
425 pipe_name(intel_crtc->pipe));
432 #define LC_FREQ_2K (LC_FREQ * 2000)
438 /* Constraints for PLL good behavior */
444 #define ABS_DIFF(a, b) ((a > b) ? (a - b) : (b - a))
450 static unsigned wrpll_get_budget_for_freq(int clock)
524 static void wrpll_update_rnp(uint64_t freq2k, unsigned budget,
525 unsigned r2, unsigned n2, unsigned p,
526 struct wrpll_rnp *best)
528 uint64_t a, b, c, d, diff, diff_best;
530 /* No best (r,n,p) yet */
539 * Output clock is (LC_FREQ_2K / 2000) * N / (P * R), which compares to
543 * abs(freq2k - (LC_FREQ_2K * n2/(p * r2))) /
546 * and we would like delta <= budget.
548 * If the discrepancy is above the PPM-based budget, always prefer to
549 * improve upon the previous solution. However, if you're within the
550 * budget, try to maximize Ref * VCO, that is N / (P * R^2).
552 a = freq2k * budget * p * r2;
553 b = freq2k * budget * best->p * best->r2;
554 diff = ABS_DIFF((freq2k * p * r2), (LC_FREQ_2K * n2));
555 diff_best = ABS_DIFF((freq2k * best->p * best->r2),
556 (LC_FREQ_2K * best->n2));
558 d = 1000000 * diff_best;
560 if (a < c && b < d) {
561 /* If both are above the budget, pick the closer */
562 if (best->p * best->r2 * diff < p * r2 * diff_best) {
567 } else if (a >= c && b < d) {
568 /* If A is below the threshold but B is above it? Update. */
572 } else if (a >= c && b >= d) {
573 /* Both are below the limit, so pick the higher n2/(r2*r2) */
574 if (n2 * best->r2 * best->r2 > best->n2 * r2 * r2) {
580 /* Otherwise a < c && b >= d, do nothing */
583 static int intel_ddi_calc_wrpll_link(struct drm_i915_private *dev_priv,
586 int refclk = LC_FREQ;
590 wrpll = I915_READ(reg);
591 switch (wrpll & WRPLL_PLL_REF_MASK) {
593 case WRPLL_PLL_NON_SSC:
595 * We could calculate spread here, but our checking
596 * code only cares about 5% accuracy, and spread is a max of
601 case WRPLL_PLL_LCPLL:
605 WARN(1, "bad wrpll refclk\n");
609 r = wrpll & WRPLL_DIVIDER_REF_MASK;
610 p = (wrpll & WRPLL_DIVIDER_POST_MASK) >> WRPLL_DIVIDER_POST_SHIFT;
611 n = (wrpll & WRPLL_DIVIDER_FB_MASK) >> WRPLL_DIVIDER_FB_SHIFT;
613 /* Convert to KHz, p & r have a fixed point portion */
614 return (refclk * n * 100) / (p * r);
617 static void hsw_ddi_clock_get(struct intel_encoder *encoder,
618 struct intel_crtc_config *pipe_config)
620 struct drm_i915_private *dev_priv = encoder->base.dev->dev_private;
624 val = pipe_config->ddi_pll_sel;
625 switch (val & PORT_CLK_SEL_MASK) {
626 case PORT_CLK_SEL_LCPLL_810:
629 case PORT_CLK_SEL_LCPLL_1350:
632 case PORT_CLK_SEL_LCPLL_2700:
635 case PORT_CLK_SEL_WRPLL1:
636 link_clock = intel_ddi_calc_wrpll_link(dev_priv, WRPLL_CTL1);
638 case PORT_CLK_SEL_WRPLL2:
639 link_clock = intel_ddi_calc_wrpll_link(dev_priv, WRPLL_CTL2);
641 case PORT_CLK_SEL_SPLL:
642 pll = I915_READ(SPLL_CTL) & SPLL_PLL_FREQ_MASK;
643 if (pll == SPLL_PLL_FREQ_810MHz)
645 else if (pll == SPLL_PLL_FREQ_1350MHz)
647 else if (pll == SPLL_PLL_FREQ_2700MHz)
650 WARN(1, "bad spll freq\n");
655 WARN(1, "bad port clock sel\n");
659 pipe_config->port_clock = link_clock * 2;
661 if (pipe_config->has_pch_encoder)
662 pipe_config->adjusted_mode.crtc_clock =
663 intel_dotclock_calculate(pipe_config->port_clock,
664 &pipe_config->fdi_m_n);
665 else if (pipe_config->has_dp_encoder)
666 pipe_config->adjusted_mode.crtc_clock =
667 intel_dotclock_calculate(pipe_config->port_clock,
668 &pipe_config->dp_m_n);
670 pipe_config->adjusted_mode.crtc_clock = pipe_config->port_clock;
673 void intel_ddi_clock_get(struct intel_encoder *encoder,
674 struct intel_crtc_config *pipe_config)
676 hsw_ddi_clock_get(encoder, pipe_config);
680 hsw_ddi_calculate_wrpll(int clock /* in Hz */,
681 unsigned *r2_out, unsigned *n2_out, unsigned *p_out)
685 struct wrpll_rnp best = { 0, 0, 0 };
688 freq2k = clock / 100;
690 budget = wrpll_get_budget_for_freq(clock);
692 /* Special case handling for 540 pixel clock: bypass WR PLL entirely
693 * and directly pass the LC PLL to it. */
694 if (freq2k == 5400000) {
702 * Ref = LC_FREQ / R, where Ref is the actual reference input seen by
705 * We want R so that REF_MIN <= Ref <= REF_MAX.
706 * Injecting R2 = 2 * R gives:
707 * REF_MAX * r2 > LC_FREQ * 2 and
708 * REF_MIN * r2 < LC_FREQ * 2
710 * Which means the desired boundaries for r2 are:
711 * LC_FREQ * 2 / REF_MAX < r2 < LC_FREQ * 2 / REF_MIN
714 for (r2 = LC_FREQ * 2 / REF_MAX + 1;
715 r2 <= LC_FREQ * 2 / REF_MIN;
719 * VCO = N * Ref, that is: VCO = N * LC_FREQ / R
721 * Once again we want VCO_MIN <= VCO <= VCO_MAX.
722 * Injecting R2 = 2 * R and N2 = 2 * N, we get:
723 * VCO_MAX * r2 > n2 * LC_FREQ and
724 * VCO_MIN * r2 < n2 * LC_FREQ)
726 * Which means the desired boundaries for n2 are:
727 * VCO_MIN * r2 / LC_FREQ < n2 < VCO_MAX * r2 / LC_FREQ
729 for (n2 = VCO_MIN * r2 / LC_FREQ + 1;
730 n2 <= VCO_MAX * r2 / LC_FREQ;
733 for (p = P_MIN; p <= P_MAX; p += P_INC)
734 wrpll_update_rnp(freq2k, budget,
745 hsw_ddi_pll_select(struct intel_crtc *intel_crtc,
746 struct intel_encoder *intel_encoder,
749 if (intel_encoder->type == INTEL_OUTPUT_HDMI) {
750 struct intel_shared_dpll *pll;
754 hsw_ddi_calculate_wrpll(clock * 1000, &r2, &n2, &p);
756 val = WRPLL_PLL_ENABLE | WRPLL_PLL_LCPLL |
757 WRPLL_DIVIDER_REFERENCE(r2) | WRPLL_DIVIDER_FEEDBACK(n2) |
758 WRPLL_DIVIDER_POST(p);
760 intel_crtc->config.dpll_hw_state.wrpll = val;
762 pll = intel_get_shared_dpll(intel_crtc);
764 DRM_DEBUG_DRIVER("failed to find PLL for pipe %c\n",
765 pipe_name(intel_crtc->pipe));
769 intel_crtc->config.ddi_pll_sel = PORT_CLK_SEL_WRPLL(pll->id);
777 * Tries to find a *shared* PLL for the CRTC and store it in
778 * intel_crtc->ddi_pll_sel.
780 * For private DPLLs, compute_config() should do the selection for us. This
781 * function should be folded into compute_config() eventually.
783 bool intel_ddi_pll_select(struct intel_crtc *intel_crtc)
785 struct drm_crtc *crtc = &intel_crtc->base;
786 struct intel_encoder *intel_encoder = intel_ddi_get_crtc_encoder(crtc);
787 int clock = intel_crtc->config.port_clock;
789 intel_put_shared_dpll(intel_crtc);
791 return hsw_ddi_pll_select(intel_crtc, intel_encoder, clock);
794 void intel_ddi_set_pipe_settings(struct drm_crtc *crtc)
796 struct drm_i915_private *dev_priv = crtc->dev->dev_private;
797 struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
798 struct intel_encoder *intel_encoder = intel_ddi_get_crtc_encoder(crtc);
799 enum transcoder cpu_transcoder = intel_crtc->config.cpu_transcoder;
800 int type = intel_encoder->type;
803 if (type == INTEL_OUTPUT_DISPLAYPORT || type == INTEL_OUTPUT_EDP || type == INTEL_OUTPUT_DP_MST) {
804 temp = TRANS_MSA_SYNC_CLK;
805 switch (intel_crtc->config.pipe_bpp) {
807 temp |= TRANS_MSA_6_BPC;
810 temp |= TRANS_MSA_8_BPC;
813 temp |= TRANS_MSA_10_BPC;
816 temp |= TRANS_MSA_12_BPC;
821 I915_WRITE(TRANS_MSA_MISC(cpu_transcoder), temp);
825 void intel_ddi_set_vc_payload_alloc(struct drm_crtc *crtc, bool state)
827 struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
828 struct drm_device *dev = crtc->dev;
829 struct drm_i915_private *dev_priv = dev->dev_private;
830 enum transcoder cpu_transcoder = intel_crtc->config.cpu_transcoder;
832 temp = I915_READ(TRANS_DDI_FUNC_CTL(cpu_transcoder));
834 temp |= TRANS_DDI_DP_VC_PAYLOAD_ALLOC;
836 temp &= ~TRANS_DDI_DP_VC_PAYLOAD_ALLOC;
837 I915_WRITE(TRANS_DDI_FUNC_CTL(cpu_transcoder), temp);
840 void intel_ddi_enable_transcoder_func(struct drm_crtc *crtc)
842 struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
843 struct intel_encoder *intel_encoder = intel_ddi_get_crtc_encoder(crtc);
844 struct drm_encoder *encoder = &intel_encoder->base;
845 struct drm_device *dev = crtc->dev;
846 struct drm_i915_private *dev_priv = dev->dev_private;
847 enum pipe pipe = intel_crtc->pipe;
848 enum transcoder cpu_transcoder = intel_crtc->config.cpu_transcoder;
849 enum port port = intel_ddi_get_encoder_port(intel_encoder);
850 int type = intel_encoder->type;
853 /* Enable TRANS_DDI_FUNC_CTL for the pipe to work in HDMI mode */
854 temp = TRANS_DDI_FUNC_ENABLE;
855 temp |= TRANS_DDI_SELECT_PORT(port);
857 switch (intel_crtc->config.pipe_bpp) {
859 temp |= TRANS_DDI_BPC_6;
862 temp |= TRANS_DDI_BPC_8;
865 temp |= TRANS_DDI_BPC_10;
868 temp |= TRANS_DDI_BPC_12;
874 if (intel_crtc->config.adjusted_mode.flags & DRM_MODE_FLAG_PVSYNC)
875 temp |= TRANS_DDI_PVSYNC;
876 if (intel_crtc->config.adjusted_mode.flags & DRM_MODE_FLAG_PHSYNC)
877 temp |= TRANS_DDI_PHSYNC;
879 if (cpu_transcoder == TRANSCODER_EDP) {
882 /* On Haswell, can only use the always-on power well for
883 * eDP when not using the panel fitter, and when not
884 * using motion blur mitigation (which we don't
886 if (IS_HASWELL(dev) &&
887 (intel_crtc->config.pch_pfit.enabled ||
888 intel_crtc->config.pch_pfit.force_thru))
889 temp |= TRANS_DDI_EDP_INPUT_A_ONOFF;
891 temp |= TRANS_DDI_EDP_INPUT_A_ON;
894 temp |= TRANS_DDI_EDP_INPUT_B_ONOFF;
897 temp |= TRANS_DDI_EDP_INPUT_C_ONOFF;
905 if (type == INTEL_OUTPUT_HDMI) {
906 if (intel_crtc->config.has_hdmi_sink)
907 temp |= TRANS_DDI_MODE_SELECT_HDMI;
909 temp |= TRANS_DDI_MODE_SELECT_DVI;
911 } else if (type == INTEL_OUTPUT_ANALOG) {
912 temp |= TRANS_DDI_MODE_SELECT_FDI;
913 temp |= (intel_crtc->config.fdi_lanes - 1) << 1;
915 } else if (type == INTEL_OUTPUT_DISPLAYPORT ||
916 type == INTEL_OUTPUT_EDP) {
917 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
919 if (intel_dp->is_mst) {
920 temp |= TRANS_DDI_MODE_SELECT_DP_MST;
922 temp |= TRANS_DDI_MODE_SELECT_DP_SST;
924 temp |= DDI_PORT_WIDTH(intel_dp->lane_count);
925 } else if (type == INTEL_OUTPUT_DP_MST) {
926 struct intel_dp *intel_dp = &enc_to_mst(encoder)->primary->dp;
928 if (intel_dp->is_mst) {
929 temp |= TRANS_DDI_MODE_SELECT_DP_MST;
931 temp |= TRANS_DDI_MODE_SELECT_DP_SST;
933 temp |= DDI_PORT_WIDTH(intel_dp->lane_count);
935 WARN(1, "Invalid encoder type %d for pipe %c\n",
936 intel_encoder->type, pipe_name(pipe));
939 I915_WRITE(TRANS_DDI_FUNC_CTL(cpu_transcoder), temp);
942 void intel_ddi_disable_transcoder_func(struct drm_i915_private *dev_priv,
943 enum transcoder cpu_transcoder)
945 uint32_t reg = TRANS_DDI_FUNC_CTL(cpu_transcoder);
946 uint32_t val = I915_READ(reg);
948 val &= ~(TRANS_DDI_FUNC_ENABLE | TRANS_DDI_PORT_MASK | TRANS_DDI_DP_VC_PAYLOAD_ALLOC);
949 val |= TRANS_DDI_PORT_NONE;
950 I915_WRITE(reg, val);
953 bool intel_ddi_connector_get_hw_state(struct intel_connector *intel_connector)
955 struct drm_device *dev = intel_connector->base.dev;
956 struct drm_i915_private *dev_priv = dev->dev_private;
957 struct intel_encoder *intel_encoder = intel_connector->encoder;
958 int type = intel_connector->base.connector_type;
959 enum port port = intel_ddi_get_encoder_port(intel_encoder);
961 enum transcoder cpu_transcoder;
962 enum intel_display_power_domain power_domain;
965 power_domain = intel_display_port_power_domain(intel_encoder);
966 if (!intel_display_power_enabled(dev_priv, power_domain))
969 if (!intel_encoder->get_hw_state(intel_encoder, &pipe))
973 cpu_transcoder = TRANSCODER_EDP;
975 cpu_transcoder = (enum transcoder) pipe;
977 tmp = I915_READ(TRANS_DDI_FUNC_CTL(cpu_transcoder));
979 switch (tmp & TRANS_DDI_MODE_SELECT_MASK) {
980 case TRANS_DDI_MODE_SELECT_HDMI:
981 case TRANS_DDI_MODE_SELECT_DVI:
982 return (type == DRM_MODE_CONNECTOR_HDMIA);
984 case TRANS_DDI_MODE_SELECT_DP_SST:
985 if (type == DRM_MODE_CONNECTOR_eDP)
987 return (type == DRM_MODE_CONNECTOR_DisplayPort);
988 case TRANS_DDI_MODE_SELECT_DP_MST:
989 /* if the transcoder is in MST state then
990 * connector isn't connected */
993 case TRANS_DDI_MODE_SELECT_FDI:
994 return (type == DRM_MODE_CONNECTOR_VGA);
1001 bool intel_ddi_get_hw_state(struct intel_encoder *encoder,
1004 struct drm_device *dev = encoder->base.dev;
1005 struct drm_i915_private *dev_priv = dev->dev_private;
1006 enum port port = intel_ddi_get_encoder_port(encoder);
1007 enum intel_display_power_domain power_domain;
1011 power_domain = intel_display_port_power_domain(encoder);
1012 if (!intel_display_power_enabled(dev_priv, power_domain))
1015 tmp = I915_READ(DDI_BUF_CTL(port));
1017 if (!(tmp & DDI_BUF_CTL_ENABLE))
1020 if (port == PORT_A) {
1021 tmp = I915_READ(TRANS_DDI_FUNC_CTL(TRANSCODER_EDP));
1023 switch (tmp & TRANS_DDI_EDP_INPUT_MASK) {
1024 case TRANS_DDI_EDP_INPUT_A_ON:
1025 case TRANS_DDI_EDP_INPUT_A_ONOFF:
1028 case TRANS_DDI_EDP_INPUT_B_ONOFF:
1031 case TRANS_DDI_EDP_INPUT_C_ONOFF:
1038 for (i = TRANSCODER_A; i <= TRANSCODER_C; i++) {
1039 tmp = I915_READ(TRANS_DDI_FUNC_CTL(i));
1041 if ((tmp & TRANS_DDI_PORT_MASK)
1042 == TRANS_DDI_SELECT_PORT(port)) {
1043 if ((tmp & TRANS_DDI_MODE_SELECT_MASK) == TRANS_DDI_MODE_SELECT_DP_MST)
1052 DRM_DEBUG_KMS("No pipe for ddi port %c found\n", port_name(port));
1057 void intel_ddi_enable_pipe_clock(struct intel_crtc *intel_crtc)
1059 struct drm_crtc *crtc = &intel_crtc->base;
1060 struct drm_i915_private *dev_priv = crtc->dev->dev_private;
1061 struct intel_encoder *intel_encoder = intel_ddi_get_crtc_encoder(crtc);
1062 enum port port = intel_ddi_get_encoder_port(intel_encoder);
1063 enum transcoder cpu_transcoder = intel_crtc->config.cpu_transcoder;
1065 if (cpu_transcoder != TRANSCODER_EDP)
1066 I915_WRITE(TRANS_CLK_SEL(cpu_transcoder),
1067 TRANS_CLK_SEL_PORT(port));
1070 void intel_ddi_disable_pipe_clock(struct intel_crtc *intel_crtc)
1072 struct drm_i915_private *dev_priv = intel_crtc->base.dev->dev_private;
1073 enum transcoder cpu_transcoder = intel_crtc->config.cpu_transcoder;
1075 if (cpu_transcoder != TRANSCODER_EDP)
1076 I915_WRITE(TRANS_CLK_SEL(cpu_transcoder),
1077 TRANS_CLK_SEL_DISABLED);
1080 static void intel_ddi_pre_enable(struct intel_encoder *intel_encoder)
1082 struct drm_encoder *encoder = &intel_encoder->base;
1083 struct drm_i915_private *dev_priv = encoder->dev->dev_private;
1084 struct intel_crtc *crtc = to_intel_crtc(encoder->crtc);
1085 enum port port = intel_ddi_get_encoder_port(intel_encoder);
1086 int type = intel_encoder->type;
1088 if (crtc->config.has_audio) {
1089 DRM_DEBUG_DRIVER("Audio on pipe %c on DDI\n",
1090 pipe_name(crtc->pipe));
1093 DRM_DEBUG_DRIVER("DDI audio: write eld information\n");
1094 intel_write_eld(encoder, &crtc->config.adjusted_mode);
1097 if (type == INTEL_OUTPUT_EDP) {
1098 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
1099 intel_edp_panel_on(intel_dp);
1102 WARN_ON(crtc->config.ddi_pll_sel == PORT_CLK_SEL_NONE);
1103 I915_WRITE(PORT_CLK_SEL(port), crtc->config.ddi_pll_sel);
1105 if (type == INTEL_OUTPUT_DISPLAYPORT || type == INTEL_OUTPUT_EDP) {
1106 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
1108 intel_ddi_init_dp_buf_reg(intel_encoder);
1110 intel_dp_sink_dpms(intel_dp, DRM_MODE_DPMS_ON);
1111 intel_dp_start_link_train(intel_dp);
1112 intel_dp_complete_link_train(intel_dp);
1114 intel_dp_stop_link_train(intel_dp);
1115 } else if (type == INTEL_OUTPUT_HDMI) {
1116 struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(encoder);
1118 intel_hdmi->set_infoframes(encoder,
1119 crtc->config.has_hdmi_sink,
1120 &crtc->config.adjusted_mode);
1124 static void intel_ddi_post_disable(struct intel_encoder *intel_encoder)
1126 struct drm_encoder *encoder = &intel_encoder->base;
1127 struct drm_i915_private *dev_priv = encoder->dev->dev_private;
1128 enum port port = intel_ddi_get_encoder_port(intel_encoder);
1129 int type = intel_encoder->type;
1133 val = I915_READ(DDI_BUF_CTL(port));
1134 if (val & DDI_BUF_CTL_ENABLE) {
1135 val &= ~DDI_BUF_CTL_ENABLE;
1136 I915_WRITE(DDI_BUF_CTL(port), val);
1140 val = I915_READ(DP_TP_CTL(port));
1141 val &= ~(DP_TP_CTL_ENABLE | DP_TP_CTL_LINK_TRAIN_MASK);
1142 val |= DP_TP_CTL_LINK_TRAIN_PAT1;
1143 I915_WRITE(DP_TP_CTL(port), val);
1146 intel_wait_ddi_buf_idle(dev_priv, port);
1148 if (type == INTEL_OUTPUT_DISPLAYPORT || type == INTEL_OUTPUT_EDP) {
1149 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
1150 intel_dp_sink_dpms(intel_dp, DRM_MODE_DPMS_OFF);
1151 intel_edp_panel_vdd_on(intel_dp);
1152 intel_edp_panel_off(intel_dp);
1155 I915_WRITE(PORT_CLK_SEL(port), PORT_CLK_SEL_NONE);
1158 static void intel_enable_ddi(struct intel_encoder *intel_encoder)
1160 struct drm_encoder *encoder = &intel_encoder->base;
1161 struct drm_crtc *crtc = encoder->crtc;
1162 struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
1163 int pipe = intel_crtc->pipe;
1164 struct drm_device *dev = encoder->dev;
1165 struct drm_i915_private *dev_priv = dev->dev_private;
1166 enum port port = intel_ddi_get_encoder_port(intel_encoder);
1167 int type = intel_encoder->type;
1170 if (type == INTEL_OUTPUT_HDMI) {
1171 struct intel_digital_port *intel_dig_port =
1172 enc_to_dig_port(encoder);
1174 /* In HDMI/DVI mode, the port width, and swing/emphasis values
1175 * are ignored so nothing special needs to be done besides
1176 * enabling the port.
1178 I915_WRITE(DDI_BUF_CTL(port),
1179 intel_dig_port->saved_port_bits |
1180 DDI_BUF_CTL_ENABLE);
1181 } else if (type == INTEL_OUTPUT_EDP) {
1182 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
1185 intel_dp_stop_link_train(intel_dp);
1187 intel_edp_backlight_on(intel_dp);
1188 intel_edp_psr_enable(intel_dp);
1191 if (intel_crtc->config.has_audio) {
1192 intel_display_power_get(dev_priv, POWER_DOMAIN_AUDIO);
1193 tmp = I915_READ(HSW_AUD_PIN_ELD_CP_VLD);
1194 tmp |= ((AUDIO_OUTPUT_ENABLE_A | AUDIO_ELD_VALID_A) << (pipe * 4));
1195 I915_WRITE(HSW_AUD_PIN_ELD_CP_VLD, tmp);
1199 static void intel_disable_ddi(struct intel_encoder *intel_encoder)
1201 struct drm_encoder *encoder = &intel_encoder->base;
1202 struct drm_crtc *crtc = encoder->crtc;
1203 struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
1204 int pipe = intel_crtc->pipe;
1205 int type = intel_encoder->type;
1206 struct drm_device *dev = encoder->dev;
1207 struct drm_i915_private *dev_priv = dev->dev_private;
1210 /* We can't touch HSW_AUD_PIN_ELD_CP_VLD uncionditionally because this
1211 * register is part of the power well on Haswell. */
1212 if (intel_crtc->config.has_audio) {
1213 tmp = I915_READ(HSW_AUD_PIN_ELD_CP_VLD);
1214 tmp &= ~((AUDIO_OUTPUT_ENABLE_A | AUDIO_ELD_VALID_A) <<
1216 I915_WRITE(HSW_AUD_PIN_ELD_CP_VLD, tmp);
1217 intel_display_power_put(dev_priv, POWER_DOMAIN_AUDIO);
1220 if (type == INTEL_OUTPUT_EDP) {
1221 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
1223 intel_edp_psr_disable(intel_dp);
1224 intel_edp_backlight_off(intel_dp);
1228 static int bdw_get_cdclk_freq(struct drm_i915_private *dev_priv)
1230 uint32_t lcpll = I915_READ(LCPLL_CTL);
1231 uint32_t freq = lcpll & LCPLL_CLK_FREQ_MASK;
1233 if (lcpll & LCPLL_CD_SOURCE_FCLK)
1235 else if (I915_READ(FUSE_STRAP) & HSW_CDCLK_LIMIT)
1237 else if (freq == LCPLL_CLK_FREQ_450)
1239 else if (freq == LCPLL_CLK_FREQ_54O_BDW)
1241 else if (freq == LCPLL_CLK_FREQ_337_5_BDW)
1247 static int hsw_get_cdclk_freq(struct drm_i915_private *dev_priv)
1249 struct drm_device *dev = dev_priv->dev;
1250 uint32_t lcpll = I915_READ(LCPLL_CTL);
1251 uint32_t freq = lcpll & LCPLL_CLK_FREQ_MASK;
1253 if (lcpll & LCPLL_CD_SOURCE_FCLK)
1255 else if (I915_READ(FUSE_STRAP) & HSW_CDCLK_LIMIT)
1257 else if (freq == LCPLL_CLK_FREQ_450)
1259 else if (IS_ULT(dev))
1265 int intel_ddi_get_cdclk_freq(struct drm_i915_private *dev_priv)
1267 struct drm_device *dev = dev_priv->dev;
1269 if (IS_BROADWELL(dev))
1270 return bdw_get_cdclk_freq(dev_priv);
1273 return hsw_get_cdclk_freq(dev_priv);
1276 static void hsw_ddi_pll_enable(struct drm_i915_private *dev_priv,
1277 struct intel_shared_dpll *pll)
1279 I915_WRITE(WRPLL_CTL(pll->id), pll->hw_state.wrpll);
1280 POSTING_READ(WRPLL_CTL(pll->id));
1284 static void hsw_ddi_pll_disable(struct drm_i915_private *dev_priv,
1285 struct intel_shared_dpll *pll)
1289 val = I915_READ(WRPLL_CTL(pll->id));
1290 I915_WRITE(WRPLL_CTL(pll->id), val & ~WRPLL_PLL_ENABLE);
1291 POSTING_READ(WRPLL_CTL(pll->id));
1294 static bool hsw_ddi_pll_get_hw_state(struct drm_i915_private *dev_priv,
1295 struct intel_shared_dpll *pll,
1296 struct intel_dpll_hw_state *hw_state)
1300 if (!intel_display_power_enabled(dev_priv, POWER_DOMAIN_PLLS))
1303 val = I915_READ(WRPLL_CTL(pll->id));
1304 hw_state->wrpll = val;
1306 return val & WRPLL_PLL_ENABLE;
1309 static const char * const hsw_ddi_pll_names[] = {
1314 static void hsw_shared_dplls_init(struct drm_i915_private *dev_priv)
1318 dev_priv->num_shared_dpll = 2;
1320 for (i = 0; i < dev_priv->num_shared_dpll; i++) {
1321 dev_priv->shared_dplls[i].id = i;
1322 dev_priv->shared_dplls[i].name = hsw_ddi_pll_names[i];
1323 dev_priv->shared_dplls[i].disable = hsw_ddi_pll_disable;
1324 dev_priv->shared_dplls[i].enable = hsw_ddi_pll_enable;
1325 dev_priv->shared_dplls[i].get_hw_state =
1326 hsw_ddi_pll_get_hw_state;
1330 void intel_ddi_pll_init(struct drm_device *dev)
1332 struct drm_i915_private *dev_priv = dev->dev_private;
1333 uint32_t val = I915_READ(LCPLL_CTL);
1335 hsw_shared_dplls_init(dev_priv);
1337 /* The LCPLL register should be turned on by the BIOS. For now let's
1338 * just check its state and print errors in case something is wrong.
1339 * Don't even try to turn it on.
1342 DRM_DEBUG_KMS("CDCLK running at %dKHz\n",
1343 intel_ddi_get_cdclk_freq(dev_priv));
1345 if (val & LCPLL_CD_SOURCE_FCLK)
1346 DRM_ERROR("CDCLK source is not LCPLL\n");
1348 if (val & LCPLL_PLL_DISABLE)
1349 DRM_ERROR("LCPLL is disabled\n");
1352 void intel_ddi_prepare_link_retrain(struct drm_encoder *encoder)
1354 struct intel_digital_port *intel_dig_port = enc_to_dig_port(encoder);
1355 struct intel_dp *intel_dp = &intel_dig_port->dp;
1356 struct drm_i915_private *dev_priv = encoder->dev->dev_private;
1357 enum port port = intel_dig_port->port;
1361 if (I915_READ(DP_TP_CTL(port)) & DP_TP_CTL_ENABLE) {
1362 val = I915_READ(DDI_BUF_CTL(port));
1363 if (val & DDI_BUF_CTL_ENABLE) {
1364 val &= ~DDI_BUF_CTL_ENABLE;
1365 I915_WRITE(DDI_BUF_CTL(port), val);
1369 val = I915_READ(DP_TP_CTL(port));
1370 val &= ~(DP_TP_CTL_ENABLE | DP_TP_CTL_LINK_TRAIN_MASK);
1371 val |= DP_TP_CTL_LINK_TRAIN_PAT1;
1372 I915_WRITE(DP_TP_CTL(port), val);
1373 POSTING_READ(DP_TP_CTL(port));
1376 intel_wait_ddi_buf_idle(dev_priv, port);
1379 val = DP_TP_CTL_ENABLE |
1380 DP_TP_CTL_LINK_TRAIN_PAT1 | DP_TP_CTL_SCRAMBLE_DISABLE;
1381 if (intel_dp->is_mst)
1382 val |= DP_TP_CTL_MODE_MST;
1384 val |= DP_TP_CTL_MODE_SST;
1385 if (drm_dp_enhanced_frame_cap(intel_dp->dpcd))
1386 val |= DP_TP_CTL_ENHANCED_FRAME_ENABLE;
1388 I915_WRITE(DP_TP_CTL(port), val);
1389 POSTING_READ(DP_TP_CTL(port));
1391 intel_dp->DP |= DDI_BUF_CTL_ENABLE;
1392 I915_WRITE(DDI_BUF_CTL(port), intel_dp->DP);
1393 POSTING_READ(DDI_BUF_CTL(port));
1398 void intel_ddi_fdi_disable(struct drm_crtc *crtc)
1400 struct drm_i915_private *dev_priv = crtc->dev->dev_private;
1401 struct intel_encoder *intel_encoder = intel_ddi_get_crtc_encoder(crtc);
1404 intel_ddi_post_disable(intel_encoder);
1406 val = I915_READ(_FDI_RXA_CTL);
1407 val &= ~FDI_RX_ENABLE;
1408 I915_WRITE(_FDI_RXA_CTL, val);
1410 val = I915_READ(_FDI_RXA_MISC);
1411 val &= ~(FDI_RX_PWRDN_LANE1_MASK | FDI_RX_PWRDN_LANE0_MASK);
1412 val |= FDI_RX_PWRDN_LANE1_VAL(2) | FDI_RX_PWRDN_LANE0_VAL(2);
1413 I915_WRITE(_FDI_RXA_MISC, val);
1415 val = I915_READ(_FDI_RXA_CTL);
1417 I915_WRITE(_FDI_RXA_CTL, val);
1419 val = I915_READ(_FDI_RXA_CTL);
1420 val &= ~FDI_RX_PLL_ENABLE;
1421 I915_WRITE(_FDI_RXA_CTL, val);
1424 static void intel_ddi_hot_plug(struct intel_encoder *intel_encoder)
1426 struct intel_digital_port *intel_dig_port = enc_to_dig_port(&intel_encoder->base);
1427 int type = intel_dig_port->base.type;
1429 if (type != INTEL_OUTPUT_DISPLAYPORT &&
1430 type != INTEL_OUTPUT_EDP &&
1431 type != INTEL_OUTPUT_UNKNOWN) {
1435 intel_dp_hot_plug(intel_encoder);
1438 void intel_ddi_get_config(struct intel_encoder *encoder,
1439 struct intel_crtc_config *pipe_config)
1441 struct drm_i915_private *dev_priv = encoder->base.dev->dev_private;
1442 struct intel_crtc *intel_crtc = to_intel_crtc(encoder->base.crtc);
1443 enum transcoder cpu_transcoder = intel_crtc->config.cpu_transcoder;
1444 u32 temp, flags = 0;
1446 temp = I915_READ(TRANS_DDI_FUNC_CTL(cpu_transcoder));
1447 if (temp & TRANS_DDI_PHSYNC)
1448 flags |= DRM_MODE_FLAG_PHSYNC;
1450 flags |= DRM_MODE_FLAG_NHSYNC;
1451 if (temp & TRANS_DDI_PVSYNC)
1452 flags |= DRM_MODE_FLAG_PVSYNC;
1454 flags |= DRM_MODE_FLAG_NVSYNC;
1456 pipe_config->adjusted_mode.flags |= flags;
1458 switch (temp & TRANS_DDI_BPC_MASK) {
1459 case TRANS_DDI_BPC_6:
1460 pipe_config->pipe_bpp = 18;
1462 case TRANS_DDI_BPC_8:
1463 pipe_config->pipe_bpp = 24;
1465 case TRANS_DDI_BPC_10:
1466 pipe_config->pipe_bpp = 30;
1468 case TRANS_DDI_BPC_12:
1469 pipe_config->pipe_bpp = 36;
1475 switch (temp & TRANS_DDI_MODE_SELECT_MASK) {
1476 case TRANS_DDI_MODE_SELECT_HDMI:
1477 pipe_config->has_hdmi_sink = true;
1478 case TRANS_DDI_MODE_SELECT_DVI:
1479 case TRANS_DDI_MODE_SELECT_FDI:
1481 case TRANS_DDI_MODE_SELECT_DP_SST:
1482 case TRANS_DDI_MODE_SELECT_DP_MST:
1483 pipe_config->has_dp_encoder = true;
1484 intel_dp_get_m_n(intel_crtc, pipe_config);
1490 if (intel_display_power_enabled(dev_priv, POWER_DOMAIN_AUDIO)) {
1491 temp = I915_READ(HSW_AUD_PIN_ELD_CP_VLD);
1492 if (temp & (AUDIO_OUTPUT_ENABLE_A << (intel_crtc->pipe * 4)))
1493 pipe_config->has_audio = true;
1496 if (encoder->type == INTEL_OUTPUT_EDP && dev_priv->vbt.edp_bpp &&
1497 pipe_config->pipe_bpp > dev_priv->vbt.edp_bpp) {
1499 * This is a big fat ugly hack.
1501 * Some machines in UEFI boot mode provide us a VBT that has 18
1502 * bpp and 1.62 GHz link bandwidth for eDP, which for reasons
1503 * unknown we fail to light up. Yet the same BIOS boots up with
1504 * 24 bpp and 2.7 GHz link. Use the same bpp as the BIOS uses as
1505 * max, not what it tells us to use.
1507 * Note: This will still be broken if the eDP panel is not lit
1508 * up by the BIOS, and thus we can't get the mode at module
1511 DRM_DEBUG_KMS("pipe has %d bpp for eDP panel, overriding BIOS-provided max %d bpp\n",
1512 pipe_config->pipe_bpp, dev_priv->vbt.edp_bpp);
1513 dev_priv->vbt.edp_bpp = pipe_config->pipe_bpp;
1516 hsw_ddi_clock_get(encoder, pipe_config);
1519 static void intel_ddi_destroy(struct drm_encoder *encoder)
1521 /* HDMI has nothing special to destroy, so we can go with this. */
1522 intel_dp_encoder_destroy(encoder);
1525 static bool intel_ddi_compute_config(struct intel_encoder *encoder,
1526 struct intel_crtc_config *pipe_config)
1528 int type = encoder->type;
1529 int port = intel_ddi_get_encoder_port(encoder);
1531 WARN(type == INTEL_OUTPUT_UNKNOWN, "compute_config() on unknown output!\n");
1534 pipe_config->cpu_transcoder = TRANSCODER_EDP;
1536 if (type == INTEL_OUTPUT_HDMI)
1537 return intel_hdmi_compute_config(encoder, pipe_config);
1539 return intel_dp_compute_config(encoder, pipe_config);
1542 static const struct drm_encoder_funcs intel_ddi_funcs = {
1543 .destroy = intel_ddi_destroy,
1546 static struct intel_connector *
1547 intel_ddi_init_dp_connector(struct intel_digital_port *intel_dig_port)
1549 struct intel_connector *connector;
1550 enum port port = intel_dig_port->port;
1552 connector = kzalloc(sizeof(*connector), GFP_KERNEL);
1556 intel_dig_port->dp.output_reg = DDI_BUF_CTL(port);
1557 if (!intel_dp_init_connector(intel_dig_port, connector)) {
1565 static struct intel_connector *
1566 intel_ddi_init_hdmi_connector(struct intel_digital_port *intel_dig_port)
1568 struct intel_connector *connector;
1569 enum port port = intel_dig_port->port;
1571 connector = kzalloc(sizeof(*connector), GFP_KERNEL);
1575 intel_dig_port->hdmi.hdmi_reg = DDI_BUF_CTL(port);
1576 intel_hdmi_init_connector(intel_dig_port, connector);
1581 void intel_ddi_init(struct drm_device *dev, enum port port)
1583 struct drm_i915_private *dev_priv = dev->dev_private;
1584 struct intel_digital_port *intel_dig_port;
1585 struct intel_encoder *intel_encoder;
1586 struct drm_encoder *encoder;
1587 bool init_hdmi, init_dp;
1589 init_hdmi = (dev_priv->vbt.ddi_port_info[port].supports_dvi ||
1590 dev_priv->vbt.ddi_port_info[port].supports_hdmi);
1591 init_dp = dev_priv->vbt.ddi_port_info[port].supports_dp;
1592 if (!init_dp && !init_hdmi) {
1593 DRM_DEBUG_KMS("VBT says port %c is not DVI/HDMI/DP compatible, assuming it is\n",
1599 intel_dig_port = kzalloc(sizeof(*intel_dig_port), GFP_KERNEL);
1600 if (!intel_dig_port)
1603 intel_encoder = &intel_dig_port->base;
1604 encoder = &intel_encoder->base;
1606 drm_encoder_init(dev, encoder, &intel_ddi_funcs,
1607 DRM_MODE_ENCODER_TMDS);
1609 intel_encoder->compute_config = intel_ddi_compute_config;
1610 intel_encoder->enable = intel_enable_ddi;
1611 intel_encoder->pre_enable = intel_ddi_pre_enable;
1612 intel_encoder->disable = intel_disable_ddi;
1613 intel_encoder->post_disable = intel_ddi_post_disable;
1614 intel_encoder->get_hw_state = intel_ddi_get_hw_state;
1615 intel_encoder->get_config = intel_ddi_get_config;
1617 intel_dig_port->port = port;
1618 intel_dig_port->saved_port_bits = I915_READ(DDI_BUF_CTL(port)) &
1619 (DDI_BUF_PORT_REVERSAL |
1622 intel_encoder->type = INTEL_OUTPUT_UNKNOWN;
1623 intel_encoder->crtc_mask = (1 << 0) | (1 << 1) | (1 << 2);
1624 intel_encoder->cloneable = 0;
1625 intel_encoder->hot_plug = intel_ddi_hot_plug;
1628 if (!intel_ddi_init_dp_connector(intel_dig_port))
1631 intel_dig_port->hpd_pulse = intel_dp_hpd_pulse;
1632 dev_priv->hpd_irq_port[port] = intel_dig_port;
1635 /* In theory we don't need the encoder->type check, but leave it just in
1636 * case we have some really bad VBTs... */
1637 if (intel_encoder->type != INTEL_OUTPUT_EDP && init_hdmi) {
1638 if (!intel_ddi_init_hdmi_connector(intel_dig_port))
1645 drm_encoder_cleanup(encoder);
1646 kfree(intel_dig_port);