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, /* DP parameters */
37 0x00D75FFF, 0x0005000A,
38 0x00C30FFF, 0x00040006,
39 0x80AAAFFF, 0x000B0000,
40 0x00FFFFFF, 0x0005000A,
41 0x00D75FFF, 0x000C0004,
42 0x80C30FFF, 0x000B0000,
43 0x00FFFFFF, 0x00040006,
44 0x80D75FFF, 0x000B0000,
45 0x00FFFFFF, 0x00040006 /* HDMI parameters */
48 static const u32 hsw_ddi_translations_fdi
[] = {
49 0x00FFFFFF, 0x0007000E, /* FDI parameters */
50 0x00D75FFF, 0x000F000A,
51 0x00C30FFF, 0x00060006,
52 0x00AAAFFF, 0x001E0000,
53 0x00FFFFFF, 0x000F000A,
54 0x00D75FFF, 0x00160004,
55 0x00C30FFF, 0x001E0000,
56 0x00FFFFFF, 0x00060006,
57 0x00D75FFF, 0x001E0000,
58 0x00FFFFFF, 0x00040006 /* HDMI parameters */
61 static enum port
intel_ddi_get_encoder_port(struct intel_encoder
*intel_encoder
)
63 struct drm_encoder
*encoder
= &intel_encoder
->base
;
64 int type
= intel_encoder
->type
;
66 if (type
== INTEL_OUTPUT_DISPLAYPORT
|| type
== INTEL_OUTPUT_EDP
) {
67 struct intel_dp
*intel_dp
= enc_to_intel_dp(encoder
);
68 return intel_dp
->port
;
70 } else if (type
== INTEL_OUTPUT_HDMI
) {
71 struct intel_hdmi
*intel_hdmi
= enc_to_intel_hdmi(encoder
);
72 return intel_hdmi
->ddi_port
;
74 } else if (type
== INTEL_OUTPUT_ANALOG
) {
78 DRM_ERROR("Invalid DDI encoder type %d\n", type
);
83 /* On Haswell, DDI port buffers must be programmed with correct values
84 * in advance. The buffer values are different for FDI and DP modes,
85 * but the HDMI/DVI fields are shared among those. So we program the DDI
86 * in either FDI or DP modes only, as HDMI connections will work with both
89 void intel_prepare_ddi_buffers(struct drm_device
*dev
, enum port port
, bool use_fdi_mode
)
91 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
94 const u32
*ddi_translations
= ((use_fdi_mode
) ?
95 hsw_ddi_translations_fdi
:
96 hsw_ddi_translations_dp
);
98 DRM_DEBUG_DRIVER("Initializing DDI buffers for port %c in %s mode\n",
100 use_fdi_mode
? "FDI" : "DP");
102 WARN((use_fdi_mode
&& (port
!= PORT_E
)),
103 "Programming port %c in FDI mode, this probably will not work.\n",
106 for (i
=0, reg
=DDI_BUF_TRANS(port
); i
< ARRAY_SIZE(hsw_ddi_translations_fdi
); i
++) {
107 I915_WRITE(reg
, ddi_translations
[i
]);
112 /* Program DDI buffers translations for DP. By default, program ports A-D in DP
113 * mode and port E for FDI.
115 void intel_prepare_ddi(struct drm_device
*dev
)
119 if (IS_HASWELL(dev
)) {
120 for (port
= PORT_A
; port
< PORT_E
; port
++)
121 intel_prepare_ddi_buffers(dev
, port
, false);
123 /* DDI E is the suggested one to work in FDI mode, so program is as such by
124 * default. It will have to be re-programmed in case a digital DP output
125 * will be detected on it
127 intel_prepare_ddi_buffers(dev
, PORT_E
, true);
131 static const long hsw_ddi_buf_ctl_values
[] = {
132 DDI_BUF_EMP_400MV_0DB_HSW
,
133 DDI_BUF_EMP_400MV_3_5DB_HSW
,
134 DDI_BUF_EMP_400MV_6DB_HSW
,
135 DDI_BUF_EMP_400MV_9_5DB_HSW
,
136 DDI_BUF_EMP_600MV_0DB_HSW
,
137 DDI_BUF_EMP_600MV_3_5DB_HSW
,
138 DDI_BUF_EMP_600MV_6DB_HSW
,
139 DDI_BUF_EMP_800MV_0DB_HSW
,
140 DDI_BUF_EMP_800MV_3_5DB_HSW
144 /* Starting with Haswell, different DDI ports can work in FDI mode for
145 * connection to the PCH-located connectors. For this, it is necessary to train
146 * both the DDI port and PCH receiver for the desired DDI buffer settings.
148 * The recommended port to work in FDI mode is DDI E, which we use here. Also,
149 * please note that when FDI mode is active on DDI E, it shares 2 lines with
150 * DDI A (which is used for eDP)
153 void hsw_fdi_link_train(struct drm_crtc
*crtc
)
155 struct drm_device
*dev
= crtc
->dev
;
156 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
157 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
158 int pipe
= intel_crtc
->pipe
;
161 /* Start the training iterating through available voltages and emphasis */
162 for (i
=0; i
< ARRAY_SIZE(hsw_ddi_buf_ctl_values
); i
++) {
163 /* Configure DP_TP_CTL with auto-training */
164 I915_WRITE(DP_TP_CTL(PORT_E
),
165 DP_TP_CTL_FDI_AUTOTRAIN
|
166 DP_TP_CTL_ENHANCED_FRAME_ENABLE
|
167 DP_TP_CTL_LINK_TRAIN_PAT1
|
170 /* Configure and enable DDI_BUF_CTL for DDI E with next voltage */
171 temp
= I915_READ(DDI_BUF_CTL(PORT_E
));
172 temp
= (temp
& ~DDI_BUF_EMP_MASK
);
173 I915_WRITE(DDI_BUF_CTL(PORT_E
),
177 hsw_ddi_buf_ctl_values
[i
]);
181 /* We need to program FDI_RX_MISC with the default TP1 to TP2
182 * values before enabling the receiver, and configure the delay
183 * for the FDI timing generator to 90h. Luckily, all the other
184 * bits are supposed to be zeroed, so we can write those values
187 I915_WRITE(FDI_RX_MISC(pipe
), FDI_RX_TP1_TO_TP2_48
|
188 FDI_RX_FDI_DELAY_90
);
190 /* Enable CPU FDI Receiver with auto-training */
191 reg
= FDI_RX_CTL(pipe
);
194 FDI_LINK_TRAIN_AUTO
|
196 FDI_LINK_TRAIN_PATTERN_1_CPT
|
197 FDI_RX_ENHANCE_FRAME_ENABLE
|
198 FDI_PORT_WIDTH_2X_LPT
|
203 temp
= I915_READ(DP_TP_STATUS(PORT_E
));
204 if (temp
& DP_TP_STATUS_AUTOTRAIN_DONE
) {
205 DRM_DEBUG_DRIVER("BUF_CTL training done on %d step\n", i
);
207 /* Enable normal pixel sending for FDI */
208 I915_WRITE(DP_TP_CTL(PORT_E
),
209 DP_TP_CTL_FDI_AUTOTRAIN
|
210 DP_TP_CTL_LINK_TRAIN_NORMAL
|
211 DP_TP_CTL_ENHANCED_FRAME_ENABLE
|
216 DRM_ERROR("Error training BUF_CTL %d\n", i
);
218 /* Disable DP_TP_CTL and FDI_RX_CTL) and retry */
219 I915_WRITE(DP_TP_CTL(PORT_E
),
220 I915_READ(DP_TP_CTL(PORT_E
)) &
222 I915_WRITE(FDI_RX_CTL(pipe
),
223 I915_READ(FDI_RX_CTL(pipe
)) &
229 DRM_DEBUG_KMS("FDI train done.\n");
232 /* For DDI connections, it is possible to support different outputs over the
233 * same DDI port, such as HDMI or DP or even VGA via FDI. So we don't know by
234 * the time the output is detected what exactly is on the other end of it. This
235 * function aims at providing support for this detection and proper output
238 void intel_ddi_init(struct drm_device
*dev
, enum port port
)
240 /* For now, we don't do any proper output detection and assume that we
241 * handle HDMI only */
245 /* We don't handle eDP and DP yet */
246 DRM_DEBUG_DRIVER("Found digital output on DDI port A\n");
248 /* Assume that the ports B, C and D are working in HDMI mode for now */
252 intel_hdmi_init(dev
, DDI_BUF_CTL(port
), port
);
255 DRM_DEBUG_DRIVER("No handlers defined for port %d, skipping DDI initialization\n",
261 /* WRPLL clock dividers */
262 struct wrpll_tmds_clock
{
264 u16 p
; /* Post divider */
265 u16 n2
; /* Feedback divider */
266 u16 r2
; /* Reference divider */
269 /* Table of matching values for WRPLL clocks programming for each frequency.
270 * The code assumes this table is sorted. */
271 static const struct wrpll_tmds_clock wrpll_tmds_clock_table
[] = {
286 {27027, 18, 100, 111},
314 {40541, 22, 147, 89},
324 {44900, 20, 108, 65},
340 {54054, 16, 173, 108},
392 {81081, 6, 100, 111},
437 {108108, 8, 173, 108},
444 {111264, 8, 150, 91},
488 {135250, 6, 167, 111},
511 {148352, 4, 100, 91},
533 {162162, 4, 131, 109},
541 {169000, 4, 104, 83},
588 {202000, 4, 112, 75},
590 {203000, 4, 146, 97},
647 void intel_ddi_mode_set(struct drm_encoder
*encoder
,
648 struct drm_display_mode
*mode
,
649 struct drm_display_mode
*adjusted_mode
)
651 struct drm_crtc
*crtc
= encoder
->crtc
;
652 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
653 struct intel_hdmi
*intel_hdmi
= enc_to_intel_hdmi(encoder
);
654 int port
= intel_hdmi
->ddi_port
;
655 int pipe
= intel_crtc
->pipe
;
657 /* On Haswell, we need to enable the clocks and prepare DDI function to
658 * work in HDMI mode for this pipe.
660 DRM_DEBUG_KMS("Preparing HDMI DDI mode for Haswell on port %c, pipe %c\n", port_name(port
), pipe_name(pipe
));
662 if (intel_hdmi
->has_audio
) {
663 /* Proper support for digital audio needs a new logic and a new set
664 * of registers, so we leave it for future patch bombing.
666 DRM_DEBUG_DRIVER("HDMI audio on pipe %c on DDI\n",
667 pipe_name(intel_crtc
->pipe
));
670 DRM_DEBUG_DRIVER("HDMI audio: write eld information\n");
671 intel_write_eld(encoder
, adjusted_mode
);
674 intel_hdmi
->set_infoframes(encoder
, adjusted_mode
);
677 static struct intel_encoder
*
678 intel_ddi_get_crtc_encoder(struct drm_crtc
*crtc
)
680 struct drm_device
*dev
= crtc
->dev
;
681 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
682 struct intel_encoder
*intel_encoder
, *ret
= NULL
;
683 int num_encoders
= 0;
685 for_each_encoder_on_crtc(dev
, crtc
, intel_encoder
) {
690 if (num_encoders
!= 1)
691 WARN(1, "%d encoders on crtc for pipe %d\n", num_encoders
,
698 void intel_ddi_put_crtc_pll(struct drm_crtc
*crtc
)
700 struct drm_i915_private
*dev_priv
= crtc
->dev
->dev_private
;
701 struct intel_ddi_plls
*plls
= &dev_priv
->ddi_plls
;
702 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
705 switch (intel_crtc
->ddi_pll_sel
) {
706 case PORT_CLK_SEL_SPLL
:
707 plls
->spll_refcount
--;
708 if (plls
->spll_refcount
== 0) {
709 DRM_DEBUG_KMS("Disabling SPLL\n");
710 val
= I915_READ(SPLL_CTL
);
711 WARN_ON(!(val
& SPLL_PLL_ENABLE
));
712 I915_WRITE(SPLL_CTL
, val
& ~SPLL_PLL_ENABLE
);
713 POSTING_READ(SPLL_CTL
);
716 case PORT_CLK_SEL_WRPLL1
:
717 plls
->wrpll1_refcount
--;
718 if (plls
->wrpll1_refcount
== 0) {
719 DRM_DEBUG_KMS("Disabling WRPLL 1\n");
720 val
= I915_READ(WRPLL_CTL1
);
721 WARN_ON(!(val
& WRPLL_PLL_ENABLE
));
722 I915_WRITE(WRPLL_CTL1
, val
& ~WRPLL_PLL_ENABLE
);
723 POSTING_READ(WRPLL_CTL1
);
726 case PORT_CLK_SEL_WRPLL2
:
727 plls
->wrpll2_refcount
--;
728 if (plls
->wrpll2_refcount
== 0) {
729 DRM_DEBUG_KMS("Disabling WRPLL 2\n");
730 val
= I915_READ(WRPLL_CTL2
);
731 WARN_ON(!(val
& WRPLL_PLL_ENABLE
));
732 I915_WRITE(WRPLL_CTL2
, val
& ~WRPLL_PLL_ENABLE
);
733 POSTING_READ(WRPLL_CTL2
);
738 WARN(plls
->spll_refcount
< 0, "Invalid SPLL refcount\n");
739 WARN(plls
->wrpll1_refcount
< 0, "Invalid WRPLL1 refcount\n");
740 WARN(plls
->wrpll2_refcount
< 0, "Invalid WRPLL2 refcount\n");
742 intel_crtc
->ddi_pll_sel
= PORT_CLK_SEL_NONE
;
745 static void intel_ddi_calculate_wrpll(int clock
, int *p
, int *n2
, int *r2
)
749 for (i
= 0; i
< ARRAY_SIZE(wrpll_tmds_clock_table
); i
++)
750 if (clock
<= wrpll_tmds_clock_table
[i
].clock
)
753 if (i
== ARRAY_SIZE(wrpll_tmds_clock_table
))
756 *p
= wrpll_tmds_clock_table
[i
].p
;
757 *n2
= wrpll_tmds_clock_table
[i
].n2
;
758 *r2
= wrpll_tmds_clock_table
[i
].r2
;
760 if (wrpll_tmds_clock_table
[i
].clock
!= clock
)
761 DRM_INFO("WRPLL: using settings for %dKHz on %dKHz mode\n",
762 wrpll_tmds_clock_table
[i
].clock
, clock
);
764 DRM_DEBUG_KMS("WRPLL: %dKHz refresh rate with p=%d, n2=%d r2=%d\n",
765 clock
, *p
, *n2
, *r2
);
768 bool intel_ddi_pll_mode_set(struct drm_crtc
*crtc
, int clock
)
770 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
771 struct intel_encoder
*intel_encoder
= intel_ddi_get_crtc_encoder(crtc
);
772 struct drm_encoder
*encoder
= &intel_encoder
->base
;
773 struct drm_i915_private
*dev_priv
= crtc
->dev
->dev_private
;
774 struct intel_ddi_plls
*plls
= &dev_priv
->ddi_plls
;
775 int type
= intel_encoder
->type
;
776 enum pipe pipe
= intel_crtc
->pipe
;
779 /* TODO: reuse PLLs when possible (compare values) */
781 intel_ddi_put_crtc_pll(crtc
);
783 if (type
== INTEL_OUTPUT_DISPLAYPORT
|| type
== INTEL_OUTPUT_EDP
) {
784 struct intel_dp
*intel_dp
= enc_to_intel_dp(encoder
);
786 switch (intel_dp
->link_bw
) {
787 case DP_LINK_BW_1_62
:
788 intel_crtc
->ddi_pll_sel
= PORT_CLK_SEL_LCPLL_810
;
791 intel_crtc
->ddi_pll_sel
= PORT_CLK_SEL_LCPLL_1350
;
794 intel_crtc
->ddi_pll_sel
= PORT_CLK_SEL_LCPLL_2700
;
797 DRM_ERROR("Link bandwidth %d unsupported\n",
802 /* We don't need to turn any PLL on because we'll use LCPLL. */
805 } else if (type
== INTEL_OUTPUT_HDMI
) {
808 if (plls
->wrpll1_refcount
== 0) {
809 DRM_DEBUG_KMS("Using WRPLL 1 on pipe %c\n",
811 plls
->wrpll1_refcount
++;
813 intel_crtc
->ddi_pll_sel
= PORT_CLK_SEL_WRPLL1
;
814 } else if (plls
->wrpll2_refcount
== 0) {
815 DRM_DEBUG_KMS("Using WRPLL 2 on pipe %c\n",
817 plls
->wrpll2_refcount
++;
819 intel_crtc
->ddi_pll_sel
= PORT_CLK_SEL_WRPLL2
;
821 DRM_ERROR("No WRPLLs available!\n");
825 WARN(I915_READ(reg
) & WRPLL_PLL_ENABLE
,
826 "WRPLL already enabled\n");
828 intel_ddi_calculate_wrpll(clock
, &p
, &n2
, &r2
);
830 val
= WRPLL_PLL_ENABLE
| WRPLL_PLL_SELECT_LCPLL_2700
|
831 WRPLL_DIVIDER_REFERENCE(r2
) | WRPLL_DIVIDER_FEEDBACK(n2
) |
832 WRPLL_DIVIDER_POST(p
);
834 } else if (type
== INTEL_OUTPUT_ANALOG
) {
835 if (plls
->spll_refcount
== 0) {
836 DRM_DEBUG_KMS("Using SPLL on pipe %c\n",
838 plls
->spll_refcount
++;
840 intel_crtc
->ddi_pll_sel
= PORT_CLK_SEL_SPLL
;
843 WARN(I915_READ(reg
) & SPLL_PLL_ENABLE
,
844 "SPLL already enabled\n");
846 val
= SPLL_PLL_ENABLE
| SPLL_PLL_FREQ_1350MHz
| SPLL_PLL_SSC
;
849 WARN(1, "Invalid DDI encoder type %d\n", type
);
853 I915_WRITE(reg
, val
);
859 void intel_ddi_set_pipe_settings(struct drm_crtc
*crtc
)
861 struct drm_i915_private
*dev_priv
= crtc
->dev
->dev_private
;
862 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
863 struct intel_encoder
*intel_encoder
= intel_ddi_get_crtc_encoder(crtc
);
864 enum pipe pipe
= intel_crtc
->pipe
;
865 int type
= intel_encoder
->type
;
868 if (type
== INTEL_OUTPUT_DISPLAYPORT
|| type
== INTEL_OUTPUT_EDP
) {
870 temp
= PIPE_MSA_SYNC_CLK
;
871 switch (intel_crtc
->bpp
) {
873 temp
|= PIPE_MSA_6_BPC
;
876 temp
|= PIPE_MSA_8_BPC
;
879 temp
|= PIPE_MSA_10_BPC
;
882 temp
|= PIPE_MSA_12_BPC
;
885 temp
|= PIPE_MSA_8_BPC
;
886 WARN(1, "%d bpp unsupported by pipe DDI function\n",
889 I915_WRITE(PIPE_MSA_MISC(pipe
), temp
);
893 void intel_ddi_enable_pipe_func(struct drm_crtc
*crtc
)
895 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
896 struct intel_encoder
*intel_encoder
= intel_ddi_get_crtc_encoder(crtc
);
897 struct drm_encoder
*encoder
= &intel_encoder
->base
;
898 struct drm_i915_private
*dev_priv
= crtc
->dev
->dev_private
;
899 enum pipe pipe
= intel_crtc
->pipe
;
900 int type
= intel_encoder
->type
;
903 /* Enable PIPE_DDI_FUNC_CTL for the pipe to work in HDMI mode */
904 temp
= PIPE_DDI_FUNC_ENABLE
;
906 switch (intel_crtc
->bpp
) {
908 temp
|= PIPE_DDI_BPC_6
;
911 temp
|= PIPE_DDI_BPC_8
;
914 temp
|= PIPE_DDI_BPC_10
;
917 temp
|= PIPE_DDI_BPC_12
;
920 WARN(1, "%d bpp unsupported by pipe DDI function\n",
924 if (crtc
->mode
.flags
& DRM_MODE_FLAG_PVSYNC
)
925 temp
|= PIPE_DDI_PVSYNC
;
926 if (crtc
->mode
.flags
& DRM_MODE_FLAG_PHSYNC
)
927 temp
|= PIPE_DDI_PHSYNC
;
929 if (type
== INTEL_OUTPUT_HDMI
) {
930 struct intel_hdmi
*intel_hdmi
= enc_to_intel_hdmi(encoder
);
932 if (intel_hdmi
->has_hdmi_sink
)
933 temp
|= PIPE_DDI_MODE_SELECT_HDMI
;
935 temp
|= PIPE_DDI_MODE_SELECT_DVI
;
937 temp
|= PIPE_DDI_SELECT_PORT(intel_hdmi
->ddi_port
);
939 } else if (type
== INTEL_OUTPUT_ANALOG
) {
940 temp
|= PIPE_DDI_MODE_SELECT_FDI
;
941 temp
|= PIPE_DDI_SELECT_PORT(PORT_E
);
943 } else if (type
== INTEL_OUTPUT_DISPLAYPORT
||
944 type
== INTEL_OUTPUT_EDP
) {
945 struct intel_dp
*intel_dp
= enc_to_intel_dp(encoder
);
947 temp
|= PIPE_DDI_MODE_SELECT_DP_SST
;
948 temp
|= PIPE_DDI_SELECT_PORT(intel_dp
->port
);
950 switch (intel_dp
->lane_count
) {
952 temp
|= PIPE_DDI_PORT_WIDTH_X1
;
955 temp
|= PIPE_DDI_PORT_WIDTH_X2
;
958 temp
|= PIPE_DDI_PORT_WIDTH_X4
;
961 temp
|= PIPE_DDI_PORT_WIDTH_X4
;
962 WARN(1, "Unsupported lane count %d\n",
963 intel_dp
->lane_count
);
967 WARN(1, "Invalid encoder type %d for pipe %d\n",
968 intel_encoder
->type
, pipe
);
971 I915_WRITE(DDI_FUNC_CTL(pipe
), temp
);
974 void intel_ddi_disable_pipe_func(struct drm_i915_private
*dev_priv
,
977 uint32_t reg
= DDI_FUNC_CTL(pipe
);
978 uint32_t val
= I915_READ(reg
);
980 val
&= ~(PIPE_DDI_FUNC_ENABLE
| PIPE_DDI_PORT_MASK
);
981 val
|= PIPE_DDI_PORT_NONE
;
982 I915_WRITE(reg
, val
);
985 bool intel_ddi_get_hw_state(struct intel_encoder
*encoder
,
988 struct drm_device
*dev
= encoder
->base
.dev
;
989 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
990 enum port port
= intel_ddi_get_encoder_port(encoder
);
994 tmp
= I915_READ(DDI_BUF_CTL(port
));
996 if (!(tmp
& DDI_BUF_CTL_ENABLE
))
1000 tmp
= I915_READ(DDI_FUNC_CTL(i
));
1002 if ((tmp
& PIPE_DDI_PORT_MASK
)
1003 == PIPE_DDI_SELECT_PORT(port
)) {
1009 DRM_DEBUG_KMS("No pipe for ddi port %i found\n", port
);
1014 static uint32_t intel_ddi_get_crtc_pll(struct drm_i915_private
*dev_priv
,
1021 temp
= I915_READ(DDI_FUNC_CTL(pipe
));
1022 temp
&= PIPE_DDI_PORT_MASK
;
1023 for (i
= PORT_A
; i
<= PORT_E
; i
++)
1024 if (temp
== PIPE_DDI_SELECT_PORT(i
))
1027 ret
= I915_READ(PORT_CLK_SEL(port
));
1029 DRM_DEBUG_KMS("Pipe %c connected to port %c using clock 0x%08x\n",
1030 pipe_name(pipe
), port_name(port
), ret
);
1035 void intel_ddi_setup_hw_pll_state(struct drm_device
*dev
)
1037 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
1039 struct intel_crtc
*intel_crtc
;
1041 for_each_pipe(pipe
) {
1043 to_intel_crtc(dev_priv
->pipe_to_crtc_mapping
[pipe
]);
1045 if (!intel_crtc
->active
)
1048 intel_crtc
->ddi_pll_sel
= intel_ddi_get_crtc_pll(dev_priv
,
1051 switch (intel_crtc
->ddi_pll_sel
) {
1052 case PORT_CLK_SEL_SPLL
:
1053 dev_priv
->ddi_plls
.spll_refcount
++;
1055 case PORT_CLK_SEL_WRPLL1
:
1056 dev_priv
->ddi_plls
.wrpll1_refcount
++;
1058 case PORT_CLK_SEL_WRPLL2
:
1059 dev_priv
->ddi_plls
.wrpll2_refcount
++;
1065 void intel_ddi_enable_pipe_clock(struct intel_crtc
*intel_crtc
)
1067 struct drm_crtc
*crtc
= &intel_crtc
->base
;
1068 struct drm_i915_private
*dev_priv
= crtc
->dev
->dev_private
;
1069 struct intel_encoder
*intel_encoder
= intel_ddi_get_crtc_encoder(crtc
);
1070 enum port port
= intel_ddi_get_encoder_port(intel_encoder
);
1072 I915_WRITE(PIPE_CLK_SEL(intel_crtc
->pipe
), PIPE_CLK_SEL_PORT(port
));
1075 void intel_ddi_disable_pipe_clock(struct intel_crtc
*intel_crtc
)
1077 struct drm_i915_private
*dev_priv
= intel_crtc
->base
.dev
->dev_private
;
1079 I915_WRITE(PIPE_CLK_SEL(intel_crtc
->pipe
), PIPE_CLK_SEL_DISABLED
);
1082 void intel_ddi_pre_enable(struct intel_encoder
*intel_encoder
)
1084 struct drm_crtc
*crtc
= intel_encoder
->base
.crtc
;
1085 struct drm_i915_private
*dev_priv
= crtc
->dev
->dev_private
;
1086 struct intel_crtc
*intel_crtc
= to_intel_crtc(crtc
);
1087 enum port port
= intel_ddi_get_encoder_port(intel_encoder
);
1089 WARN_ON(intel_crtc
->ddi_pll_sel
== PORT_CLK_SEL_NONE
);
1091 I915_WRITE(PORT_CLK_SEL(port
), intel_crtc
->ddi_pll_sel
);
1094 static void intel_wait_ddi_buf_idle(struct drm_i915_private
*dev_priv
,
1097 uint32_t reg
= DDI_BUF_CTL(port
);
1100 for (i
= 0; i
< 8; i
++) {
1102 if (I915_READ(reg
) & DDI_BUF_IS_IDLE
)
1105 DRM_ERROR("Timeout waiting for DDI BUF %c idle bit\n", port_name(port
));
1108 void intel_ddi_post_disable(struct intel_encoder
*intel_encoder
)
1110 struct drm_encoder
*encoder
= &intel_encoder
->base
;
1111 struct drm_i915_private
*dev_priv
= encoder
->dev
->dev_private
;
1112 enum port port
= intel_ddi_get_encoder_port(intel_encoder
);
1115 val
= I915_READ(DDI_BUF_CTL(port
));
1116 if (val
& DDI_BUF_CTL_ENABLE
) {
1117 val
&= ~DDI_BUF_CTL_ENABLE
;
1118 I915_WRITE(DDI_BUF_CTL(port
), val
);
1119 intel_wait_ddi_buf_idle(dev_priv
, port
);
1122 I915_WRITE(PORT_CLK_SEL(port
), PORT_CLK_SEL_NONE
);
1125 void intel_enable_ddi(struct intel_encoder
*intel_encoder
)
1127 struct drm_encoder
*encoder
= &intel_encoder
->base
;
1128 struct drm_device
*dev
= encoder
->dev
;
1129 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
1130 enum port port
= intel_ddi_get_encoder_port(intel_encoder
);
1131 int type
= intel_encoder
->type
;
1133 if (type
== INTEL_OUTPUT_HDMI
) {
1134 /* In HDMI/DVI mode, the port width, and swing/emphasis values
1135 * are ignored so nothing special needs to be done besides
1136 * enabling the port.
1138 I915_WRITE(DDI_BUF_CTL(port
), DDI_BUF_CTL_ENABLE
);
1142 void intel_disable_ddi(struct intel_encoder
*encoder
)
1144 /* This will be needed in the future, so leave it here for now */
1147 static int intel_ddi_get_cdclk_freq(struct drm_i915_private
*dev_priv
)
1149 if (I915_READ(HSW_FUSE_STRAP
) & HSW_CDCLK_LIMIT
)
1151 else if ((I915_READ(LCPLL_CTL
) & LCPLL_CLK_FREQ_MASK
) ==
1158 void intel_ddi_pll_init(struct drm_device
*dev
)
1160 struct drm_i915_private
*dev_priv
= dev
->dev_private
;
1161 uint32_t val
= I915_READ(LCPLL_CTL
);
1163 /* The LCPLL register should be turned on by the BIOS. For now let's
1164 * just check its state and print errors in case something is wrong.
1165 * Don't even try to turn it on.
1168 DRM_DEBUG_KMS("CDCLK running at %dMHz\n",
1169 intel_ddi_get_cdclk_freq(dev_priv
));
1171 if (val
& LCPLL_CD_SOURCE_FCLK
)
1172 DRM_ERROR("CDCLK source is not LCPLL\n");
1174 if (val
& LCPLL_PLL_DISABLE
)
1175 DRM_ERROR("LCPLL is disabled\n");