Loading...
1/*
2 * Copyright © 2012 Intel Corporation
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 (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
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
21 * IN THE SOFTWARE.
22 *
23 * Authors:
24 * Eugeni Dodonov <eugeni.dodonov@intel.com>
25 *
26 */
27
28#include "i915_drv.h"
29#include "intel_drv.h"
30
31struct ddi_buf_trans {
32 u32 trans1; /* balance leg enable, de-emph level */
33 u32 trans2; /* vref sel, vswing */
34 u8 i_boost; /* SKL: I_boost; valid: 0x0, 0x1, 0x3, 0x7 */
35};
36
37/* HDMI/DVI modes ignore everything but the last 2 items. So we share
38 * them for both DP and FDI transports, allowing those ports to
39 * automatically adapt to HDMI connections as well
40 */
41static const struct ddi_buf_trans hsw_ddi_translations_dp[] = {
42 { 0x00FFFFFF, 0x0006000E, 0x0 },
43 { 0x00D75FFF, 0x0005000A, 0x0 },
44 { 0x00C30FFF, 0x00040006, 0x0 },
45 { 0x80AAAFFF, 0x000B0000, 0x0 },
46 { 0x00FFFFFF, 0x0005000A, 0x0 },
47 { 0x00D75FFF, 0x000C0004, 0x0 },
48 { 0x80C30FFF, 0x000B0000, 0x0 },
49 { 0x00FFFFFF, 0x00040006, 0x0 },
50 { 0x80D75FFF, 0x000B0000, 0x0 },
51};
52
53static const struct ddi_buf_trans hsw_ddi_translations_fdi[] = {
54 { 0x00FFFFFF, 0x0007000E, 0x0 },
55 { 0x00D75FFF, 0x000F000A, 0x0 },
56 { 0x00C30FFF, 0x00060006, 0x0 },
57 { 0x00AAAFFF, 0x001E0000, 0x0 },
58 { 0x00FFFFFF, 0x000F000A, 0x0 },
59 { 0x00D75FFF, 0x00160004, 0x0 },
60 { 0x00C30FFF, 0x001E0000, 0x0 },
61 { 0x00FFFFFF, 0x00060006, 0x0 },
62 { 0x00D75FFF, 0x001E0000, 0x0 },
63};
64
65static const struct ddi_buf_trans hsw_ddi_translations_hdmi[] = {
66 /* Idx NT mV d T mV d db */
67 { 0x00FFFFFF, 0x0006000E, 0x0 },/* 0: 400 400 0 */
68 { 0x00E79FFF, 0x000E000C, 0x0 },/* 1: 400 500 2 */
69 { 0x00D75FFF, 0x0005000A, 0x0 },/* 2: 400 600 3.5 */
70 { 0x00FFFFFF, 0x0005000A, 0x0 },/* 3: 600 600 0 */
71 { 0x00E79FFF, 0x001D0007, 0x0 },/* 4: 600 750 2 */
72 { 0x00D75FFF, 0x000C0004, 0x0 },/* 5: 600 900 3.5 */
73 { 0x00FFFFFF, 0x00040006, 0x0 },/* 6: 800 800 0 */
74 { 0x80E79FFF, 0x00030002, 0x0 },/* 7: 800 1000 2 */
75 { 0x00FFFFFF, 0x00140005, 0x0 },/* 8: 850 850 0 */
76 { 0x00FFFFFF, 0x000C0004, 0x0 },/* 9: 900 900 0 */
77 { 0x00FFFFFF, 0x001C0003, 0x0 },/* 10: 950 950 0 */
78 { 0x80FFFFFF, 0x00030002, 0x0 },/* 11: 1000 1000 0 */
79};
80
81static const struct ddi_buf_trans bdw_ddi_translations_edp[] = {
82 { 0x00FFFFFF, 0x00000012, 0x0 },
83 { 0x00EBAFFF, 0x00020011, 0x0 },
84 { 0x00C71FFF, 0x0006000F, 0x0 },
85 { 0x00AAAFFF, 0x000E000A, 0x0 },
86 { 0x00FFFFFF, 0x00020011, 0x0 },
87 { 0x00DB6FFF, 0x0005000F, 0x0 },
88 { 0x00BEEFFF, 0x000A000C, 0x0 },
89 { 0x00FFFFFF, 0x0005000F, 0x0 },
90 { 0x00DB6FFF, 0x000A000C, 0x0 },
91};
92
93static const struct ddi_buf_trans bdw_ddi_translations_dp[] = {
94 { 0x00FFFFFF, 0x0007000E, 0x0 },
95 { 0x00D75FFF, 0x000E000A, 0x0 },
96 { 0x00BEFFFF, 0x00140006, 0x0 },
97 { 0x80B2CFFF, 0x001B0002, 0x0 },
98 { 0x00FFFFFF, 0x000E000A, 0x0 },
99 { 0x00DB6FFF, 0x00160005, 0x0 },
100 { 0x80C71FFF, 0x001A0002, 0x0 },
101 { 0x00F7DFFF, 0x00180004, 0x0 },
102 { 0x80D75FFF, 0x001B0002, 0x0 },
103};
104
105static const struct ddi_buf_trans bdw_ddi_translations_fdi[] = {
106 { 0x00FFFFFF, 0x0001000E, 0x0 },
107 { 0x00D75FFF, 0x0004000A, 0x0 },
108 { 0x00C30FFF, 0x00070006, 0x0 },
109 { 0x00AAAFFF, 0x000C0000, 0x0 },
110 { 0x00FFFFFF, 0x0004000A, 0x0 },
111 { 0x00D75FFF, 0x00090004, 0x0 },
112 { 0x00C30FFF, 0x000C0000, 0x0 },
113 { 0x00FFFFFF, 0x00070006, 0x0 },
114 { 0x00D75FFF, 0x000C0000, 0x0 },
115};
116
117static const struct ddi_buf_trans bdw_ddi_translations_hdmi[] = {
118 /* Idx NT mV d T mV df db */
119 { 0x00FFFFFF, 0x0007000E, 0x0 },/* 0: 400 400 0 */
120 { 0x00D75FFF, 0x000E000A, 0x0 },/* 1: 400 600 3.5 */
121 { 0x00BEFFFF, 0x00140006, 0x0 },/* 2: 400 800 6 */
122 { 0x00FFFFFF, 0x0009000D, 0x0 },/* 3: 450 450 0 */
123 { 0x00FFFFFF, 0x000E000A, 0x0 },/* 4: 600 600 0 */
124 { 0x00D7FFFF, 0x00140006, 0x0 },/* 5: 600 800 2.5 */
125 { 0x80CB2FFF, 0x001B0002, 0x0 },/* 6: 600 1000 4.5 */
126 { 0x00FFFFFF, 0x00140006, 0x0 },/* 7: 800 800 0 */
127 { 0x80E79FFF, 0x001B0002, 0x0 },/* 8: 800 1000 2 */
128 { 0x80FFFFFF, 0x001B0002, 0x0 },/* 9: 1000 1000 0 */
129};
130
131/* Skylake H and S */
132static const struct ddi_buf_trans skl_ddi_translations_dp[] = {
133 { 0x00002016, 0x000000A0, 0x0 },
134 { 0x00005012, 0x0000009B, 0x0 },
135 { 0x00007011, 0x00000088, 0x0 },
136 { 0x80009010, 0x000000C0, 0x1 },
137 { 0x00002016, 0x0000009B, 0x0 },
138 { 0x00005012, 0x00000088, 0x0 },
139 { 0x80007011, 0x000000C0, 0x1 },
140 { 0x00002016, 0x000000DF, 0x0 },
141 { 0x80005012, 0x000000C0, 0x1 },
142};
143
144/* Skylake U */
145static const struct ddi_buf_trans skl_u_ddi_translations_dp[] = {
146 { 0x0000201B, 0x000000A2, 0x0 },
147 { 0x00005012, 0x00000088, 0x0 },
148 { 0x80007011, 0x000000CD, 0x0 },
149 { 0x80009010, 0x000000C0, 0x1 },
150 { 0x0000201B, 0x0000009D, 0x0 },
151 { 0x80005012, 0x000000C0, 0x1 },
152 { 0x80007011, 0x000000C0, 0x1 },
153 { 0x00002016, 0x00000088, 0x0 },
154 { 0x80005012, 0x000000C0, 0x1 },
155};
156
157/* Skylake Y */
158static const struct ddi_buf_trans skl_y_ddi_translations_dp[] = {
159 { 0x00000018, 0x000000A2, 0x0 },
160 { 0x00005012, 0x00000088, 0x0 },
161 { 0x80007011, 0x000000CD, 0x0 },
162 { 0x80009010, 0x000000C0, 0x3 },
163 { 0x00000018, 0x0000009D, 0x0 },
164 { 0x80005012, 0x000000C0, 0x3 },
165 { 0x80007011, 0x000000C0, 0x3 },
166 { 0x00000018, 0x00000088, 0x0 },
167 { 0x80005012, 0x000000C0, 0x3 },
168};
169
170/*
171 * Skylake H and S
172 * eDP 1.4 low vswing translation parameters
173 */
174static const struct ddi_buf_trans skl_ddi_translations_edp[] = {
175 { 0x00000018, 0x000000A8, 0x0 },
176 { 0x00004013, 0x000000A9, 0x0 },
177 { 0x00007011, 0x000000A2, 0x0 },
178 { 0x00009010, 0x0000009C, 0x0 },
179 { 0x00000018, 0x000000A9, 0x0 },
180 { 0x00006013, 0x000000A2, 0x0 },
181 { 0x00007011, 0x000000A6, 0x0 },
182 { 0x00000018, 0x000000AB, 0x0 },
183 { 0x00007013, 0x0000009F, 0x0 },
184 { 0x00000018, 0x000000DF, 0x0 },
185};
186
187/*
188 * Skylake U
189 * eDP 1.4 low vswing translation parameters
190 */
191static const struct ddi_buf_trans skl_u_ddi_translations_edp[] = {
192 { 0x00000018, 0x000000A8, 0x0 },
193 { 0x00004013, 0x000000A9, 0x0 },
194 { 0x00007011, 0x000000A2, 0x0 },
195 { 0x00009010, 0x0000009C, 0x0 },
196 { 0x00000018, 0x000000A9, 0x0 },
197 { 0x00006013, 0x000000A2, 0x0 },
198 { 0x00007011, 0x000000A6, 0x0 },
199 { 0x00002016, 0x000000AB, 0x0 },
200 { 0x00005013, 0x0000009F, 0x0 },
201 { 0x00000018, 0x000000DF, 0x0 },
202};
203
204/*
205 * Skylake Y
206 * eDP 1.4 low vswing translation parameters
207 */
208static const struct ddi_buf_trans skl_y_ddi_translations_edp[] = {
209 { 0x00000018, 0x000000A8, 0x0 },
210 { 0x00004013, 0x000000AB, 0x0 },
211 { 0x00007011, 0x000000A4, 0x0 },
212 { 0x00009010, 0x000000DF, 0x0 },
213 { 0x00000018, 0x000000AA, 0x0 },
214 { 0x00006013, 0x000000A4, 0x0 },
215 { 0x00007011, 0x0000009D, 0x0 },
216 { 0x00000018, 0x000000A0, 0x0 },
217 { 0x00006012, 0x000000DF, 0x0 },
218 { 0x00000018, 0x0000008A, 0x0 },
219};
220
221/* Skylake U, H and S */
222static const struct ddi_buf_trans skl_ddi_translations_hdmi[] = {
223 { 0x00000018, 0x000000AC, 0x0 },
224 { 0x00005012, 0x0000009D, 0x0 },
225 { 0x00007011, 0x00000088, 0x0 },
226 { 0x00000018, 0x000000A1, 0x0 },
227 { 0x00000018, 0x00000098, 0x0 },
228 { 0x00004013, 0x00000088, 0x0 },
229 { 0x80006012, 0x000000CD, 0x1 },
230 { 0x00000018, 0x000000DF, 0x0 },
231 { 0x80003015, 0x000000CD, 0x1 }, /* Default */
232 { 0x80003015, 0x000000C0, 0x1 },
233 { 0x80000018, 0x000000C0, 0x1 },
234};
235
236/* Skylake Y */
237static const struct ddi_buf_trans skl_y_ddi_translations_hdmi[] = {
238 { 0x00000018, 0x000000A1, 0x0 },
239 { 0x00005012, 0x000000DF, 0x0 },
240 { 0x80007011, 0x000000CB, 0x3 },
241 { 0x00000018, 0x000000A4, 0x0 },
242 { 0x00000018, 0x0000009D, 0x0 },
243 { 0x00004013, 0x00000080, 0x0 },
244 { 0x80006013, 0x000000C0, 0x3 },
245 { 0x00000018, 0x0000008A, 0x0 },
246 { 0x80003015, 0x000000C0, 0x3 }, /* Default */
247 { 0x80003015, 0x000000C0, 0x3 },
248 { 0x80000018, 0x000000C0, 0x3 },
249};
250
251struct bxt_ddi_buf_trans {
252 u32 margin; /* swing value */
253 u32 scale; /* scale value */
254 u32 enable; /* scale enable */
255 u32 deemphasis;
256 bool default_index; /* true if the entry represents default value */
257};
258
259static const struct bxt_ddi_buf_trans bxt_ddi_translations_dp[] = {
260 /* Idx NT mV diff db */
261 { 52, 0x9A, 0, 128, true }, /* 0: 400 0 */
262 { 78, 0x9A, 0, 85, false }, /* 1: 400 3.5 */
263 { 104, 0x9A, 0, 64, false }, /* 2: 400 6 */
264 { 154, 0x9A, 0, 43, false }, /* 3: 400 9.5 */
265 { 77, 0x9A, 0, 128, false }, /* 4: 600 0 */
266 { 116, 0x9A, 0, 85, false }, /* 5: 600 3.5 */
267 { 154, 0x9A, 0, 64, false }, /* 6: 600 6 */
268 { 102, 0x9A, 0, 128, false }, /* 7: 800 0 */
269 { 154, 0x9A, 0, 85, false }, /* 8: 800 3.5 */
270 { 154, 0x9A, 1, 128, false }, /* 9: 1200 0 */
271};
272
273static const struct bxt_ddi_buf_trans bxt_ddi_translations_edp[] = {
274 /* Idx NT mV diff db */
275 { 26, 0, 0, 128, false }, /* 0: 200 0 */
276 { 38, 0, 0, 112, false }, /* 1: 200 1.5 */
277 { 48, 0, 0, 96, false }, /* 2: 200 4 */
278 { 54, 0, 0, 69, false }, /* 3: 200 6 */
279 { 32, 0, 0, 128, false }, /* 4: 250 0 */
280 { 48, 0, 0, 104, false }, /* 5: 250 1.5 */
281 { 54, 0, 0, 85, false }, /* 6: 250 4 */
282 { 43, 0, 0, 128, false }, /* 7: 300 0 */
283 { 54, 0, 0, 101, false }, /* 8: 300 1.5 */
284 { 48, 0, 0, 128, false }, /* 9: 300 0 */
285};
286
287/* BSpec has 2 recommended values - entries 0 and 8.
288 * Using the entry with higher vswing.
289 */
290static const struct bxt_ddi_buf_trans bxt_ddi_translations_hdmi[] = {
291 /* Idx NT mV diff db */
292 { 52, 0x9A, 0, 128, false }, /* 0: 400 0 */
293 { 52, 0x9A, 0, 85, false }, /* 1: 400 3.5 */
294 { 52, 0x9A, 0, 64, false }, /* 2: 400 6 */
295 { 42, 0x9A, 0, 43, false }, /* 3: 400 9.5 */
296 { 77, 0x9A, 0, 128, false }, /* 4: 600 0 */
297 { 77, 0x9A, 0, 85, false }, /* 5: 600 3.5 */
298 { 77, 0x9A, 0, 64, false }, /* 6: 600 6 */
299 { 102, 0x9A, 0, 128, false }, /* 7: 800 0 */
300 { 102, 0x9A, 0, 85, false }, /* 8: 800 3.5 */
301 { 154, 0x9A, 1, 128, true }, /* 9: 1200 0 */
302};
303
304static void bxt_ddi_vswing_sequence(struct drm_i915_private *dev_priv,
305 u32 level, enum port port, int type);
306
307static void ddi_get_encoder_port(struct intel_encoder *intel_encoder,
308 struct intel_digital_port **dig_port,
309 enum port *port)
310{
311 struct drm_encoder *encoder = &intel_encoder->base;
312
313 switch (intel_encoder->type) {
314 case INTEL_OUTPUT_DP_MST:
315 *dig_port = enc_to_mst(encoder)->primary;
316 *port = (*dig_port)->port;
317 break;
318 case INTEL_OUTPUT_DISPLAYPORT:
319 case INTEL_OUTPUT_EDP:
320 case INTEL_OUTPUT_HDMI:
321 case INTEL_OUTPUT_UNKNOWN:
322 *dig_port = enc_to_dig_port(encoder);
323 *port = (*dig_port)->port;
324 break;
325 case INTEL_OUTPUT_ANALOG:
326 *dig_port = NULL;
327 *port = PORT_E;
328 break;
329 default:
330 WARN(1, "Invalid DDI encoder type %d\n", intel_encoder->type);
331 break;
332 }
333}
334
335enum port intel_ddi_get_encoder_port(struct intel_encoder *intel_encoder)
336{
337 struct intel_digital_port *dig_port;
338 enum port port;
339
340 ddi_get_encoder_port(intel_encoder, &dig_port, &port);
341
342 return port;
343}
344
345static const struct ddi_buf_trans *
346skl_get_buf_trans_dp(struct drm_i915_private *dev_priv, int *n_entries)
347{
348 if (IS_SKL_ULX(dev_priv) || IS_KBL_ULX(dev_priv)) {
349 *n_entries = ARRAY_SIZE(skl_y_ddi_translations_dp);
350 return skl_y_ddi_translations_dp;
351 } else if (IS_SKL_ULT(dev_priv) || IS_KBL_ULT(dev_priv)) {
352 *n_entries = ARRAY_SIZE(skl_u_ddi_translations_dp);
353 return skl_u_ddi_translations_dp;
354 } else {
355 *n_entries = ARRAY_SIZE(skl_ddi_translations_dp);
356 return skl_ddi_translations_dp;
357 }
358}
359
360static const struct ddi_buf_trans *
361skl_get_buf_trans_edp(struct drm_i915_private *dev_priv, int *n_entries)
362{
363 if (dev_priv->edp_low_vswing) {
364 if (IS_SKL_ULX(dev_priv) || IS_KBL_ULX(dev_priv)) {
365 *n_entries = ARRAY_SIZE(skl_y_ddi_translations_edp);
366 return skl_y_ddi_translations_edp;
367 } else if (IS_SKL_ULT(dev_priv) || IS_KBL_ULT(dev_priv)) {
368 *n_entries = ARRAY_SIZE(skl_u_ddi_translations_edp);
369 return skl_u_ddi_translations_edp;
370 } else {
371 *n_entries = ARRAY_SIZE(skl_ddi_translations_edp);
372 return skl_ddi_translations_edp;
373 }
374 }
375
376 return skl_get_buf_trans_dp(dev_priv, n_entries);
377}
378
379static const struct ddi_buf_trans *
380skl_get_buf_trans_hdmi(struct drm_i915_private *dev_priv, int *n_entries)
381{
382 if (IS_SKL_ULX(dev_priv) || IS_KBL_ULX(dev_priv)) {
383 *n_entries = ARRAY_SIZE(skl_y_ddi_translations_hdmi);
384 return skl_y_ddi_translations_hdmi;
385 } else {
386 *n_entries = ARRAY_SIZE(skl_ddi_translations_hdmi);
387 return skl_ddi_translations_hdmi;
388 }
389}
390
391/*
392 * Starting with Haswell, DDI port buffers must be programmed with correct
393 * values in advance. The buffer values are different for FDI and DP modes,
394 * but the HDMI/DVI fields are shared among those. So we program the DDI
395 * in either FDI or DP modes only, as HDMI connections will work with both
396 * of those
397 */
398void intel_prepare_ddi_buffer(struct intel_encoder *encoder)
399{
400 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
401 u32 iboost_bit = 0;
402 int i, n_hdmi_entries, n_dp_entries, n_edp_entries, hdmi_default_entry,
403 size;
404 int hdmi_level;
405 enum port port;
406 const struct ddi_buf_trans *ddi_translations_fdi;
407 const struct ddi_buf_trans *ddi_translations_dp;
408 const struct ddi_buf_trans *ddi_translations_edp;
409 const struct ddi_buf_trans *ddi_translations_hdmi;
410 const struct ddi_buf_trans *ddi_translations;
411
412 port = intel_ddi_get_encoder_port(encoder);
413 hdmi_level = dev_priv->vbt.ddi_port_info[port].hdmi_level_shift;
414
415 if (IS_BROXTON(dev_priv)) {
416 if (encoder->type != INTEL_OUTPUT_HDMI)
417 return;
418
419 /* Vswing programming for HDMI */
420 bxt_ddi_vswing_sequence(dev_priv, hdmi_level, port,
421 INTEL_OUTPUT_HDMI);
422 return;
423 }
424
425 if (IS_SKYLAKE(dev_priv) || IS_KABYLAKE(dev_priv)) {
426 ddi_translations_fdi = NULL;
427 ddi_translations_dp =
428 skl_get_buf_trans_dp(dev_priv, &n_dp_entries);
429 ddi_translations_edp =
430 skl_get_buf_trans_edp(dev_priv, &n_edp_entries);
431 ddi_translations_hdmi =
432 skl_get_buf_trans_hdmi(dev_priv, &n_hdmi_entries);
433 hdmi_default_entry = 8;
434 /* If we're boosting the current, set bit 31 of trans1 */
435 if (dev_priv->vbt.ddi_port_info[port].hdmi_boost_level ||
436 dev_priv->vbt.ddi_port_info[port].dp_boost_level)
437 iboost_bit = 1<<31;
438
439 if (WARN_ON(encoder->type == INTEL_OUTPUT_EDP &&
440 port != PORT_A && port != PORT_E &&
441 n_edp_entries > 9))
442 n_edp_entries = 9;
443 } else if (IS_BROADWELL(dev_priv)) {
444 ddi_translations_fdi = bdw_ddi_translations_fdi;
445 ddi_translations_dp = bdw_ddi_translations_dp;
446
447 if (dev_priv->edp_low_vswing) {
448 ddi_translations_edp = bdw_ddi_translations_edp;
449 n_edp_entries = ARRAY_SIZE(bdw_ddi_translations_edp);
450 } else {
451 ddi_translations_edp = bdw_ddi_translations_dp;
452 n_edp_entries = ARRAY_SIZE(bdw_ddi_translations_dp);
453 }
454
455 ddi_translations_hdmi = bdw_ddi_translations_hdmi;
456
457 n_dp_entries = ARRAY_SIZE(bdw_ddi_translations_dp);
458 n_hdmi_entries = ARRAY_SIZE(bdw_ddi_translations_hdmi);
459 hdmi_default_entry = 7;
460 } else if (IS_HASWELL(dev_priv)) {
461 ddi_translations_fdi = hsw_ddi_translations_fdi;
462 ddi_translations_dp = hsw_ddi_translations_dp;
463 ddi_translations_edp = hsw_ddi_translations_dp;
464 ddi_translations_hdmi = hsw_ddi_translations_hdmi;
465 n_dp_entries = n_edp_entries = ARRAY_SIZE(hsw_ddi_translations_dp);
466 n_hdmi_entries = ARRAY_SIZE(hsw_ddi_translations_hdmi);
467 hdmi_default_entry = 6;
468 } else {
469 WARN(1, "ddi translation table missing\n");
470 ddi_translations_edp = bdw_ddi_translations_dp;
471 ddi_translations_fdi = bdw_ddi_translations_fdi;
472 ddi_translations_dp = bdw_ddi_translations_dp;
473 ddi_translations_hdmi = bdw_ddi_translations_hdmi;
474 n_edp_entries = ARRAY_SIZE(bdw_ddi_translations_edp);
475 n_dp_entries = ARRAY_SIZE(bdw_ddi_translations_dp);
476 n_hdmi_entries = ARRAY_SIZE(bdw_ddi_translations_hdmi);
477 hdmi_default_entry = 7;
478 }
479
480 switch (encoder->type) {
481 case INTEL_OUTPUT_EDP:
482 ddi_translations = ddi_translations_edp;
483 size = n_edp_entries;
484 break;
485 case INTEL_OUTPUT_DISPLAYPORT:
486 case INTEL_OUTPUT_HDMI:
487 ddi_translations = ddi_translations_dp;
488 size = n_dp_entries;
489 break;
490 case INTEL_OUTPUT_ANALOG:
491 ddi_translations = ddi_translations_fdi;
492 size = n_dp_entries;
493 break;
494 default:
495 BUG();
496 }
497
498 for (i = 0; i < size; i++) {
499 I915_WRITE(DDI_BUF_TRANS_LO(port, i),
500 ddi_translations[i].trans1 | iboost_bit);
501 I915_WRITE(DDI_BUF_TRANS_HI(port, i),
502 ddi_translations[i].trans2);
503 }
504
505 if (encoder->type != INTEL_OUTPUT_HDMI)
506 return;
507
508 /* Choose a good default if VBT is badly populated */
509 if (hdmi_level == HDMI_LEVEL_SHIFT_UNKNOWN ||
510 hdmi_level >= n_hdmi_entries)
511 hdmi_level = hdmi_default_entry;
512
513 /* Entry 9 is for HDMI: */
514 I915_WRITE(DDI_BUF_TRANS_LO(port, i),
515 ddi_translations_hdmi[hdmi_level].trans1 | iboost_bit);
516 I915_WRITE(DDI_BUF_TRANS_HI(port, i),
517 ddi_translations_hdmi[hdmi_level].trans2);
518}
519
520static void intel_wait_ddi_buf_idle(struct drm_i915_private *dev_priv,
521 enum port port)
522{
523 i915_reg_t reg = DDI_BUF_CTL(port);
524 int i;
525
526 for (i = 0; i < 16; i++) {
527 udelay(1);
528 if (I915_READ(reg) & DDI_BUF_IS_IDLE)
529 return;
530 }
531 DRM_ERROR("Timeout waiting for DDI BUF %c idle bit\n", port_name(port));
532}
533
534/* Starting with Haswell, different DDI ports can work in FDI mode for
535 * connection to the PCH-located connectors. For this, it is necessary to train
536 * both the DDI port and PCH receiver for the desired DDI buffer settings.
537 *
538 * The recommended port to work in FDI mode is DDI E, which we use here. Also,
539 * please note that when FDI mode is active on DDI E, it shares 2 lines with
540 * DDI A (which is used for eDP)
541 */
542
543void hsw_fdi_link_train(struct drm_crtc *crtc)
544{
545 struct drm_device *dev = crtc->dev;
546 struct drm_i915_private *dev_priv = dev->dev_private;
547 struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
548 struct intel_encoder *encoder;
549 u32 temp, i, rx_ctl_val;
550
551 for_each_encoder_on_crtc(dev, crtc, encoder) {
552 WARN_ON(encoder->type != INTEL_OUTPUT_ANALOG);
553 intel_prepare_ddi_buffer(encoder);
554 }
555
556 /* Set the FDI_RX_MISC pwrdn lanes and the 2 workarounds listed at the
557 * mode set "sequence for CRT port" document:
558 * - TP1 to TP2 time with the default value
559 * - FDI delay to 90h
560 *
561 * WaFDIAutoLinkSetTimingOverrride:hsw
562 */
563 I915_WRITE(FDI_RX_MISC(PIPE_A), FDI_RX_PWRDN_LANE1_VAL(2) |
564 FDI_RX_PWRDN_LANE0_VAL(2) |
565 FDI_RX_TP1_TO_TP2_48 | FDI_RX_FDI_DELAY_90);
566
567 /* Enable the PCH Receiver FDI PLL */
568 rx_ctl_val = dev_priv->fdi_rx_config | FDI_RX_ENHANCE_FRAME_ENABLE |
569 FDI_RX_PLL_ENABLE |
570 FDI_DP_PORT_WIDTH(intel_crtc->config->fdi_lanes);
571 I915_WRITE(FDI_RX_CTL(PIPE_A), rx_ctl_val);
572 POSTING_READ(FDI_RX_CTL(PIPE_A));
573 udelay(220);
574
575 /* Switch from Rawclk to PCDclk */
576 rx_ctl_val |= FDI_PCDCLK;
577 I915_WRITE(FDI_RX_CTL(PIPE_A), rx_ctl_val);
578
579 /* Configure Port Clock Select */
580 I915_WRITE(PORT_CLK_SEL(PORT_E), intel_crtc->config->ddi_pll_sel);
581 WARN_ON(intel_crtc->config->ddi_pll_sel != PORT_CLK_SEL_SPLL);
582
583 /* Start the training iterating through available voltages and emphasis,
584 * testing each value twice. */
585 for (i = 0; i < ARRAY_SIZE(hsw_ddi_translations_fdi) * 2; i++) {
586 /* Configure DP_TP_CTL with auto-training */
587 I915_WRITE(DP_TP_CTL(PORT_E),
588 DP_TP_CTL_FDI_AUTOTRAIN |
589 DP_TP_CTL_ENHANCED_FRAME_ENABLE |
590 DP_TP_CTL_LINK_TRAIN_PAT1 |
591 DP_TP_CTL_ENABLE);
592
593 /* Configure and enable DDI_BUF_CTL for DDI E with next voltage.
594 * DDI E does not support port reversal, the functionality is
595 * achieved on the PCH side in FDI_RX_CTL, so no need to set the
596 * port reversal bit */
597 I915_WRITE(DDI_BUF_CTL(PORT_E),
598 DDI_BUF_CTL_ENABLE |
599 ((intel_crtc->config->fdi_lanes - 1) << 1) |
600 DDI_BUF_TRANS_SELECT(i / 2));
601 POSTING_READ(DDI_BUF_CTL(PORT_E));
602
603 udelay(600);
604
605 /* Program PCH FDI Receiver TU */
606 I915_WRITE(FDI_RX_TUSIZE1(PIPE_A), TU_SIZE(64));
607
608 /* Enable PCH FDI Receiver with auto-training */
609 rx_ctl_val |= FDI_RX_ENABLE | FDI_LINK_TRAIN_AUTO;
610 I915_WRITE(FDI_RX_CTL(PIPE_A), rx_ctl_val);
611 POSTING_READ(FDI_RX_CTL(PIPE_A));
612
613 /* Wait for FDI receiver lane calibration */
614 udelay(30);
615
616 /* Unset FDI_RX_MISC pwrdn lanes */
617 temp = I915_READ(FDI_RX_MISC(PIPE_A));
618 temp &= ~(FDI_RX_PWRDN_LANE1_MASK | FDI_RX_PWRDN_LANE0_MASK);
619 I915_WRITE(FDI_RX_MISC(PIPE_A), temp);
620 POSTING_READ(FDI_RX_MISC(PIPE_A));
621
622 /* Wait for FDI auto training time */
623 udelay(5);
624
625 temp = I915_READ(DP_TP_STATUS(PORT_E));
626 if (temp & DP_TP_STATUS_AUTOTRAIN_DONE) {
627 DRM_DEBUG_KMS("FDI link training done on step %d\n", i);
628 break;
629 }
630
631 /*
632 * Leave things enabled even if we failed to train FDI.
633 * Results in less fireworks from the state checker.
634 */
635 if (i == ARRAY_SIZE(hsw_ddi_translations_fdi) * 2 - 1) {
636 DRM_ERROR("FDI link training failed!\n");
637 break;
638 }
639
640 temp = I915_READ(DDI_BUF_CTL(PORT_E));
641 temp &= ~DDI_BUF_CTL_ENABLE;
642 I915_WRITE(DDI_BUF_CTL(PORT_E), temp);
643 POSTING_READ(DDI_BUF_CTL(PORT_E));
644
645 /* Disable DP_TP_CTL and FDI_RX_CTL and retry */
646 temp = I915_READ(DP_TP_CTL(PORT_E));
647 temp &= ~(DP_TP_CTL_ENABLE | DP_TP_CTL_LINK_TRAIN_MASK);
648 temp |= DP_TP_CTL_LINK_TRAIN_PAT1;
649 I915_WRITE(DP_TP_CTL(PORT_E), temp);
650 POSTING_READ(DP_TP_CTL(PORT_E));
651
652 intel_wait_ddi_buf_idle(dev_priv, PORT_E);
653
654 rx_ctl_val &= ~FDI_RX_ENABLE;
655 I915_WRITE(FDI_RX_CTL(PIPE_A), rx_ctl_val);
656 POSTING_READ(FDI_RX_CTL(PIPE_A));
657
658 /* Reset FDI_RX_MISC pwrdn lanes */
659 temp = I915_READ(FDI_RX_MISC(PIPE_A));
660 temp &= ~(FDI_RX_PWRDN_LANE1_MASK | FDI_RX_PWRDN_LANE0_MASK);
661 temp |= FDI_RX_PWRDN_LANE1_VAL(2) | FDI_RX_PWRDN_LANE0_VAL(2);
662 I915_WRITE(FDI_RX_MISC(PIPE_A), temp);
663 POSTING_READ(FDI_RX_MISC(PIPE_A));
664 }
665
666 /* Enable normal pixel sending for FDI */
667 I915_WRITE(DP_TP_CTL(PORT_E),
668 DP_TP_CTL_FDI_AUTOTRAIN |
669 DP_TP_CTL_LINK_TRAIN_NORMAL |
670 DP_TP_CTL_ENHANCED_FRAME_ENABLE |
671 DP_TP_CTL_ENABLE);
672}
673
674void intel_ddi_init_dp_buf_reg(struct intel_encoder *encoder)
675{
676 struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
677 struct intel_digital_port *intel_dig_port =
678 enc_to_dig_port(&encoder->base);
679
680 intel_dp->DP = intel_dig_port->saved_port_bits |
681 DDI_BUF_CTL_ENABLE | DDI_BUF_TRANS_SELECT(0);
682 intel_dp->DP |= DDI_PORT_WIDTH(intel_dp->lane_count);
683}
684
685static struct intel_encoder *
686intel_ddi_get_crtc_encoder(struct drm_crtc *crtc)
687{
688 struct drm_device *dev = crtc->dev;
689 struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
690 struct intel_encoder *intel_encoder, *ret = NULL;
691 int num_encoders = 0;
692
693 for_each_encoder_on_crtc(dev, crtc, intel_encoder) {
694 ret = intel_encoder;
695 num_encoders++;
696 }
697
698 if (num_encoders != 1)
699 WARN(1, "%d encoders on crtc for pipe %c\n", num_encoders,
700 pipe_name(intel_crtc->pipe));
701
702 BUG_ON(ret == NULL);
703 return ret;
704}
705
706struct intel_encoder *
707intel_ddi_get_crtc_new_encoder(struct intel_crtc_state *crtc_state)
708{
709 struct intel_crtc *crtc = to_intel_crtc(crtc_state->base.crtc);
710 struct intel_encoder *ret = NULL;
711 struct drm_atomic_state *state;
712 struct drm_connector *connector;
713 struct drm_connector_state *connector_state;
714 int num_encoders = 0;
715 int i;
716
717 state = crtc_state->base.state;
718
719 for_each_connector_in_state(state, connector, connector_state, i) {
720 if (connector_state->crtc != crtc_state->base.crtc)
721 continue;
722
723 ret = to_intel_encoder(connector_state->best_encoder);
724 num_encoders++;
725 }
726
727 WARN(num_encoders != 1, "%d encoders on crtc for pipe %c\n", num_encoders,
728 pipe_name(crtc->pipe));
729
730 BUG_ON(ret == NULL);
731 return ret;
732}
733
734#define LC_FREQ 2700
735#define LC_FREQ_2K U64_C(LC_FREQ * 2000)
736
737#define P_MIN 2
738#define P_MAX 64
739#define P_INC 2
740
741/* Constraints for PLL good behavior */
742#define REF_MIN 48
743#define REF_MAX 400
744#define VCO_MIN 2400
745#define VCO_MAX 4800
746
747#define abs_diff(a, b) ({ \
748 typeof(a) __a = (a); \
749 typeof(b) __b = (b); \
750 (void) (&__a == &__b); \
751 __a > __b ? (__a - __b) : (__b - __a); })
752
753struct hsw_wrpll_rnp {
754 unsigned p, n2, r2;
755};
756
757static unsigned hsw_wrpll_get_budget_for_freq(int clock)
758{
759 unsigned budget;
760
761 switch (clock) {
762 case 25175000:
763 case 25200000:
764 case 27000000:
765 case 27027000:
766 case 37762500:
767 case 37800000:
768 case 40500000:
769 case 40541000:
770 case 54000000:
771 case 54054000:
772 case 59341000:
773 case 59400000:
774 case 72000000:
775 case 74176000:
776 case 74250000:
777 case 81000000:
778 case 81081000:
779 case 89012000:
780 case 89100000:
781 case 108000000:
782 case 108108000:
783 case 111264000:
784 case 111375000:
785 case 148352000:
786 case 148500000:
787 case 162000000:
788 case 162162000:
789 case 222525000:
790 case 222750000:
791 case 296703000:
792 case 297000000:
793 budget = 0;
794 break;
795 case 233500000:
796 case 245250000:
797 case 247750000:
798 case 253250000:
799 case 298000000:
800 budget = 1500;
801 break;
802 case 169128000:
803 case 169500000:
804 case 179500000:
805 case 202000000:
806 budget = 2000;
807 break;
808 case 256250000:
809 case 262500000:
810 case 270000000:
811 case 272500000:
812 case 273750000:
813 case 280750000:
814 case 281250000:
815 case 286000000:
816 case 291750000:
817 budget = 4000;
818 break;
819 case 267250000:
820 case 268500000:
821 budget = 5000;
822 break;
823 default:
824 budget = 1000;
825 break;
826 }
827
828 return budget;
829}
830
831static void hsw_wrpll_update_rnp(uint64_t freq2k, unsigned budget,
832 unsigned r2, unsigned n2, unsigned p,
833 struct hsw_wrpll_rnp *best)
834{
835 uint64_t a, b, c, d, diff, diff_best;
836
837 /* No best (r,n,p) yet */
838 if (best->p == 0) {
839 best->p = p;
840 best->n2 = n2;
841 best->r2 = r2;
842 return;
843 }
844
845 /*
846 * Output clock is (LC_FREQ_2K / 2000) * N / (P * R), which compares to
847 * freq2k.
848 *
849 * delta = 1e6 *
850 * abs(freq2k - (LC_FREQ_2K * n2/(p * r2))) /
851 * freq2k;
852 *
853 * and we would like delta <= budget.
854 *
855 * If the discrepancy is above the PPM-based budget, always prefer to
856 * improve upon the previous solution. However, if you're within the
857 * budget, try to maximize Ref * VCO, that is N / (P * R^2).
858 */
859 a = freq2k * budget * p * r2;
860 b = freq2k * budget * best->p * best->r2;
861 diff = abs_diff(freq2k * p * r2, LC_FREQ_2K * n2);
862 diff_best = abs_diff(freq2k * best->p * best->r2,
863 LC_FREQ_2K * best->n2);
864 c = 1000000 * diff;
865 d = 1000000 * diff_best;
866
867 if (a < c && b < d) {
868 /* If both are above the budget, pick the closer */
869 if (best->p * best->r2 * diff < p * r2 * diff_best) {
870 best->p = p;
871 best->n2 = n2;
872 best->r2 = r2;
873 }
874 } else if (a >= c && b < d) {
875 /* If A is below the threshold but B is above it? Update. */
876 best->p = p;
877 best->n2 = n2;
878 best->r2 = r2;
879 } else if (a >= c && b >= d) {
880 /* Both are below the limit, so pick the higher n2/(r2*r2) */
881 if (n2 * best->r2 * best->r2 > best->n2 * r2 * r2) {
882 best->p = p;
883 best->n2 = n2;
884 best->r2 = r2;
885 }
886 }
887 /* Otherwise a < c && b >= d, do nothing */
888}
889
890static int hsw_ddi_calc_wrpll_link(struct drm_i915_private *dev_priv,
891 i915_reg_t reg)
892{
893 int refclk = LC_FREQ;
894 int n, p, r;
895 u32 wrpll;
896
897 wrpll = I915_READ(reg);
898 switch (wrpll & WRPLL_PLL_REF_MASK) {
899 case WRPLL_PLL_SSC:
900 case WRPLL_PLL_NON_SSC:
901 /*
902 * We could calculate spread here, but our checking
903 * code only cares about 5% accuracy, and spread is a max of
904 * 0.5% downspread.
905 */
906 refclk = 135;
907 break;
908 case WRPLL_PLL_LCPLL:
909 refclk = LC_FREQ;
910 break;
911 default:
912 WARN(1, "bad wrpll refclk\n");
913 return 0;
914 }
915
916 r = wrpll & WRPLL_DIVIDER_REF_MASK;
917 p = (wrpll & WRPLL_DIVIDER_POST_MASK) >> WRPLL_DIVIDER_POST_SHIFT;
918 n = (wrpll & WRPLL_DIVIDER_FB_MASK) >> WRPLL_DIVIDER_FB_SHIFT;
919
920 /* Convert to KHz, p & r have a fixed point portion */
921 return (refclk * n * 100) / (p * r);
922}
923
924static int skl_calc_wrpll_link(struct drm_i915_private *dev_priv,
925 uint32_t dpll)
926{
927 i915_reg_t cfgcr1_reg, cfgcr2_reg;
928 uint32_t cfgcr1_val, cfgcr2_val;
929 uint32_t p0, p1, p2, dco_freq;
930
931 cfgcr1_reg = DPLL_CFGCR1(dpll);
932 cfgcr2_reg = DPLL_CFGCR2(dpll);
933
934 cfgcr1_val = I915_READ(cfgcr1_reg);
935 cfgcr2_val = I915_READ(cfgcr2_reg);
936
937 p0 = cfgcr2_val & DPLL_CFGCR2_PDIV_MASK;
938 p2 = cfgcr2_val & DPLL_CFGCR2_KDIV_MASK;
939
940 if (cfgcr2_val & DPLL_CFGCR2_QDIV_MODE(1))
941 p1 = (cfgcr2_val & DPLL_CFGCR2_QDIV_RATIO_MASK) >> 8;
942 else
943 p1 = 1;
944
945
946 switch (p0) {
947 case DPLL_CFGCR2_PDIV_1:
948 p0 = 1;
949 break;
950 case DPLL_CFGCR2_PDIV_2:
951 p0 = 2;
952 break;
953 case DPLL_CFGCR2_PDIV_3:
954 p0 = 3;
955 break;
956 case DPLL_CFGCR2_PDIV_7:
957 p0 = 7;
958 break;
959 }
960
961 switch (p2) {
962 case DPLL_CFGCR2_KDIV_5:
963 p2 = 5;
964 break;
965 case DPLL_CFGCR2_KDIV_2:
966 p2 = 2;
967 break;
968 case DPLL_CFGCR2_KDIV_3:
969 p2 = 3;
970 break;
971 case DPLL_CFGCR2_KDIV_1:
972 p2 = 1;
973 break;
974 }
975
976 dco_freq = (cfgcr1_val & DPLL_CFGCR1_DCO_INTEGER_MASK) * 24 * 1000;
977
978 dco_freq += (((cfgcr1_val & DPLL_CFGCR1_DCO_FRACTION_MASK) >> 9) * 24 *
979 1000) / 0x8000;
980
981 return dco_freq / (p0 * p1 * p2 * 5);
982}
983
984static void ddi_dotclock_get(struct intel_crtc_state *pipe_config)
985{
986 int dotclock;
987
988 if (pipe_config->has_pch_encoder)
989 dotclock = intel_dotclock_calculate(pipe_config->port_clock,
990 &pipe_config->fdi_m_n);
991 else if (pipe_config->has_dp_encoder)
992 dotclock = intel_dotclock_calculate(pipe_config->port_clock,
993 &pipe_config->dp_m_n);
994 else if (pipe_config->has_hdmi_sink && pipe_config->pipe_bpp == 36)
995 dotclock = pipe_config->port_clock * 2 / 3;
996 else
997 dotclock = pipe_config->port_clock;
998
999 if (pipe_config->pixel_multiplier)
1000 dotclock /= pipe_config->pixel_multiplier;
1001
1002 pipe_config->base.adjusted_mode.crtc_clock = dotclock;
1003}
1004
1005static void skl_ddi_clock_get(struct intel_encoder *encoder,
1006 struct intel_crtc_state *pipe_config)
1007{
1008 struct drm_i915_private *dev_priv = encoder->base.dev->dev_private;
1009 int link_clock = 0;
1010 uint32_t dpll_ctl1, dpll;
1011
1012 dpll = pipe_config->ddi_pll_sel;
1013
1014 dpll_ctl1 = I915_READ(DPLL_CTRL1);
1015
1016 if (dpll_ctl1 & DPLL_CTRL1_HDMI_MODE(dpll)) {
1017 link_clock = skl_calc_wrpll_link(dev_priv, dpll);
1018 } else {
1019 link_clock = dpll_ctl1 & DPLL_CTRL1_LINK_RATE_MASK(dpll);
1020 link_clock >>= DPLL_CTRL1_LINK_RATE_SHIFT(dpll);
1021
1022 switch (link_clock) {
1023 case DPLL_CTRL1_LINK_RATE_810:
1024 link_clock = 81000;
1025 break;
1026 case DPLL_CTRL1_LINK_RATE_1080:
1027 link_clock = 108000;
1028 break;
1029 case DPLL_CTRL1_LINK_RATE_1350:
1030 link_clock = 135000;
1031 break;
1032 case DPLL_CTRL1_LINK_RATE_1620:
1033 link_clock = 162000;
1034 break;
1035 case DPLL_CTRL1_LINK_RATE_2160:
1036 link_clock = 216000;
1037 break;
1038 case DPLL_CTRL1_LINK_RATE_2700:
1039 link_clock = 270000;
1040 break;
1041 default:
1042 WARN(1, "Unsupported link rate\n");
1043 break;
1044 }
1045 link_clock *= 2;
1046 }
1047
1048 pipe_config->port_clock = link_clock;
1049
1050 ddi_dotclock_get(pipe_config);
1051}
1052
1053static void hsw_ddi_clock_get(struct intel_encoder *encoder,
1054 struct intel_crtc_state *pipe_config)
1055{
1056 struct drm_i915_private *dev_priv = encoder->base.dev->dev_private;
1057 int link_clock = 0;
1058 u32 val, pll;
1059
1060 val = pipe_config->ddi_pll_sel;
1061 switch (val & PORT_CLK_SEL_MASK) {
1062 case PORT_CLK_SEL_LCPLL_810:
1063 link_clock = 81000;
1064 break;
1065 case PORT_CLK_SEL_LCPLL_1350:
1066 link_clock = 135000;
1067 break;
1068 case PORT_CLK_SEL_LCPLL_2700:
1069 link_clock = 270000;
1070 break;
1071 case PORT_CLK_SEL_WRPLL1:
1072 link_clock = hsw_ddi_calc_wrpll_link(dev_priv, WRPLL_CTL(0));
1073 break;
1074 case PORT_CLK_SEL_WRPLL2:
1075 link_clock = hsw_ddi_calc_wrpll_link(dev_priv, WRPLL_CTL(1));
1076 break;
1077 case PORT_CLK_SEL_SPLL:
1078 pll = I915_READ(SPLL_CTL) & SPLL_PLL_FREQ_MASK;
1079 if (pll == SPLL_PLL_FREQ_810MHz)
1080 link_clock = 81000;
1081 else if (pll == SPLL_PLL_FREQ_1350MHz)
1082 link_clock = 135000;
1083 else if (pll == SPLL_PLL_FREQ_2700MHz)
1084 link_clock = 270000;
1085 else {
1086 WARN(1, "bad spll freq\n");
1087 return;
1088 }
1089 break;
1090 default:
1091 WARN(1, "bad port clock sel\n");
1092 return;
1093 }
1094
1095 pipe_config->port_clock = link_clock * 2;
1096
1097 ddi_dotclock_get(pipe_config);
1098}
1099
1100static int bxt_calc_pll_link(struct drm_i915_private *dev_priv,
1101 enum intel_dpll_id dpll)
1102{
1103 struct intel_shared_dpll *pll;
1104 struct intel_dpll_hw_state *state;
1105 intel_clock_t clock;
1106
1107 /* For DDI ports we always use a shared PLL. */
1108 if (WARN_ON(dpll == DPLL_ID_PRIVATE))
1109 return 0;
1110
1111 pll = &dev_priv->shared_dplls[dpll];
1112 state = &pll->config.hw_state;
1113
1114 clock.m1 = 2;
1115 clock.m2 = (state->pll0 & PORT_PLL_M2_MASK) << 22;
1116 if (state->pll3 & PORT_PLL_M2_FRAC_ENABLE)
1117 clock.m2 |= state->pll2 & PORT_PLL_M2_FRAC_MASK;
1118 clock.n = (state->pll1 & PORT_PLL_N_MASK) >> PORT_PLL_N_SHIFT;
1119 clock.p1 = (state->ebb0 & PORT_PLL_P1_MASK) >> PORT_PLL_P1_SHIFT;
1120 clock.p2 = (state->ebb0 & PORT_PLL_P2_MASK) >> PORT_PLL_P2_SHIFT;
1121
1122 return chv_calc_dpll_params(100000, &clock);
1123}
1124
1125static void bxt_ddi_clock_get(struct intel_encoder *encoder,
1126 struct intel_crtc_state *pipe_config)
1127{
1128 struct drm_i915_private *dev_priv = encoder->base.dev->dev_private;
1129 enum port port = intel_ddi_get_encoder_port(encoder);
1130 uint32_t dpll = port;
1131
1132 pipe_config->port_clock = bxt_calc_pll_link(dev_priv, dpll);
1133
1134 ddi_dotclock_get(pipe_config);
1135}
1136
1137void intel_ddi_clock_get(struct intel_encoder *encoder,
1138 struct intel_crtc_state *pipe_config)
1139{
1140 struct drm_device *dev = encoder->base.dev;
1141
1142 if (INTEL_INFO(dev)->gen <= 8)
1143 hsw_ddi_clock_get(encoder, pipe_config);
1144 else if (IS_SKYLAKE(dev) || IS_KABYLAKE(dev))
1145 skl_ddi_clock_get(encoder, pipe_config);
1146 else if (IS_BROXTON(dev))
1147 bxt_ddi_clock_get(encoder, pipe_config);
1148}
1149
1150static void
1151hsw_ddi_calculate_wrpll(int clock /* in Hz */,
1152 unsigned *r2_out, unsigned *n2_out, unsigned *p_out)
1153{
1154 uint64_t freq2k;
1155 unsigned p, n2, r2;
1156 struct hsw_wrpll_rnp best = { 0, 0, 0 };
1157 unsigned budget;
1158
1159 freq2k = clock / 100;
1160
1161 budget = hsw_wrpll_get_budget_for_freq(clock);
1162
1163 /* Special case handling for 540 pixel clock: bypass WR PLL entirely
1164 * and directly pass the LC PLL to it. */
1165 if (freq2k == 5400000) {
1166 *n2_out = 2;
1167 *p_out = 1;
1168 *r2_out = 2;
1169 return;
1170 }
1171
1172 /*
1173 * Ref = LC_FREQ / R, where Ref is the actual reference input seen by
1174 * the WR PLL.
1175 *
1176 * We want R so that REF_MIN <= Ref <= REF_MAX.
1177 * Injecting R2 = 2 * R gives:
1178 * REF_MAX * r2 > LC_FREQ * 2 and
1179 * REF_MIN * r2 < LC_FREQ * 2
1180 *
1181 * Which means the desired boundaries for r2 are:
1182 * LC_FREQ * 2 / REF_MAX < r2 < LC_FREQ * 2 / REF_MIN
1183 *
1184 */
1185 for (r2 = LC_FREQ * 2 / REF_MAX + 1;
1186 r2 <= LC_FREQ * 2 / REF_MIN;
1187 r2++) {
1188
1189 /*
1190 * VCO = N * Ref, that is: VCO = N * LC_FREQ / R
1191 *
1192 * Once again we want VCO_MIN <= VCO <= VCO_MAX.
1193 * Injecting R2 = 2 * R and N2 = 2 * N, we get:
1194 * VCO_MAX * r2 > n2 * LC_FREQ and
1195 * VCO_MIN * r2 < n2 * LC_FREQ)
1196 *
1197 * Which means the desired boundaries for n2 are:
1198 * VCO_MIN * r2 / LC_FREQ < n2 < VCO_MAX * r2 / LC_FREQ
1199 */
1200 for (n2 = VCO_MIN * r2 / LC_FREQ + 1;
1201 n2 <= VCO_MAX * r2 / LC_FREQ;
1202 n2++) {
1203
1204 for (p = P_MIN; p <= P_MAX; p += P_INC)
1205 hsw_wrpll_update_rnp(freq2k, budget,
1206 r2, n2, p, &best);
1207 }
1208 }
1209
1210 *n2_out = best.n2;
1211 *p_out = best.p;
1212 *r2_out = best.r2;
1213}
1214
1215static bool
1216hsw_ddi_pll_select(struct intel_crtc *intel_crtc,
1217 struct intel_crtc_state *crtc_state,
1218 struct intel_encoder *intel_encoder)
1219{
1220 int clock = crtc_state->port_clock;
1221
1222 if (intel_encoder->type == INTEL_OUTPUT_HDMI) {
1223 struct intel_shared_dpll *pll;
1224 uint32_t val;
1225 unsigned p, n2, r2;
1226
1227 hsw_ddi_calculate_wrpll(clock * 1000, &r2, &n2, &p);
1228
1229 val = WRPLL_PLL_ENABLE | WRPLL_PLL_LCPLL |
1230 WRPLL_DIVIDER_REFERENCE(r2) | WRPLL_DIVIDER_FEEDBACK(n2) |
1231 WRPLL_DIVIDER_POST(p);
1232
1233 memset(&crtc_state->dpll_hw_state, 0,
1234 sizeof(crtc_state->dpll_hw_state));
1235
1236 crtc_state->dpll_hw_state.wrpll = val;
1237
1238 pll = intel_get_shared_dpll(intel_crtc, crtc_state);
1239 if (pll == NULL) {
1240 DRM_DEBUG_DRIVER("failed to find PLL for pipe %c\n",
1241 pipe_name(intel_crtc->pipe));
1242 return false;
1243 }
1244
1245 crtc_state->ddi_pll_sel = PORT_CLK_SEL_WRPLL(pll->id);
1246 } else if (crtc_state->ddi_pll_sel == PORT_CLK_SEL_SPLL) {
1247 struct drm_atomic_state *state = crtc_state->base.state;
1248 struct intel_shared_dpll_config *spll =
1249 &intel_atomic_get_shared_dpll_state(state)[DPLL_ID_SPLL];
1250
1251 if (spll->crtc_mask &&
1252 WARN_ON(spll->hw_state.spll != crtc_state->dpll_hw_state.spll))
1253 return false;
1254
1255 crtc_state->shared_dpll = DPLL_ID_SPLL;
1256 spll->hw_state.spll = crtc_state->dpll_hw_state.spll;
1257 spll->crtc_mask |= 1 << intel_crtc->pipe;
1258 }
1259
1260 return true;
1261}
1262
1263struct skl_wrpll_context {
1264 uint64_t min_deviation; /* current minimal deviation */
1265 uint64_t central_freq; /* chosen central freq */
1266 uint64_t dco_freq; /* chosen dco freq */
1267 unsigned int p; /* chosen divider */
1268};
1269
1270static void skl_wrpll_context_init(struct skl_wrpll_context *ctx)
1271{
1272 memset(ctx, 0, sizeof(*ctx));
1273
1274 ctx->min_deviation = U64_MAX;
1275}
1276
1277/* DCO freq must be within +1%/-6% of the DCO central freq */
1278#define SKL_DCO_MAX_PDEVIATION 100
1279#define SKL_DCO_MAX_NDEVIATION 600
1280
1281static void skl_wrpll_try_divider(struct skl_wrpll_context *ctx,
1282 uint64_t central_freq,
1283 uint64_t dco_freq,
1284 unsigned int divider)
1285{
1286 uint64_t deviation;
1287
1288 deviation = div64_u64(10000 * abs_diff(dco_freq, central_freq),
1289 central_freq);
1290
1291 /* positive deviation */
1292 if (dco_freq >= central_freq) {
1293 if (deviation < SKL_DCO_MAX_PDEVIATION &&
1294 deviation < ctx->min_deviation) {
1295 ctx->min_deviation = deviation;
1296 ctx->central_freq = central_freq;
1297 ctx->dco_freq = dco_freq;
1298 ctx->p = divider;
1299 }
1300 /* negative deviation */
1301 } else if (deviation < SKL_DCO_MAX_NDEVIATION &&
1302 deviation < ctx->min_deviation) {
1303 ctx->min_deviation = deviation;
1304 ctx->central_freq = central_freq;
1305 ctx->dco_freq = dco_freq;
1306 ctx->p = divider;
1307 }
1308}
1309
1310static void skl_wrpll_get_multipliers(unsigned int p,
1311 unsigned int *p0 /* out */,
1312 unsigned int *p1 /* out */,
1313 unsigned int *p2 /* out */)
1314{
1315 /* even dividers */
1316 if (p % 2 == 0) {
1317 unsigned int half = p / 2;
1318
1319 if (half == 1 || half == 2 || half == 3 || half == 5) {
1320 *p0 = 2;
1321 *p1 = 1;
1322 *p2 = half;
1323 } else if (half % 2 == 0) {
1324 *p0 = 2;
1325 *p1 = half / 2;
1326 *p2 = 2;
1327 } else if (half % 3 == 0) {
1328 *p0 = 3;
1329 *p1 = half / 3;
1330 *p2 = 2;
1331 } else if (half % 7 == 0) {
1332 *p0 = 7;
1333 *p1 = half / 7;
1334 *p2 = 2;
1335 }
1336 } else if (p == 3 || p == 9) { /* 3, 5, 7, 9, 15, 21, 35 */
1337 *p0 = 3;
1338 *p1 = 1;
1339 *p2 = p / 3;
1340 } else if (p == 5 || p == 7) {
1341 *p0 = p;
1342 *p1 = 1;
1343 *p2 = 1;
1344 } else if (p == 15) {
1345 *p0 = 3;
1346 *p1 = 1;
1347 *p2 = 5;
1348 } else if (p == 21) {
1349 *p0 = 7;
1350 *p1 = 1;
1351 *p2 = 3;
1352 } else if (p == 35) {
1353 *p0 = 7;
1354 *p1 = 1;
1355 *p2 = 5;
1356 }
1357}
1358
1359struct skl_wrpll_params {
1360 uint32_t dco_fraction;
1361 uint32_t dco_integer;
1362 uint32_t qdiv_ratio;
1363 uint32_t qdiv_mode;
1364 uint32_t kdiv;
1365 uint32_t pdiv;
1366 uint32_t central_freq;
1367};
1368
1369static void skl_wrpll_params_populate(struct skl_wrpll_params *params,
1370 uint64_t afe_clock,
1371 uint64_t central_freq,
1372 uint32_t p0, uint32_t p1, uint32_t p2)
1373{
1374 uint64_t dco_freq;
1375
1376 switch (central_freq) {
1377 case 9600000000ULL:
1378 params->central_freq = 0;
1379 break;
1380 case 9000000000ULL:
1381 params->central_freq = 1;
1382 break;
1383 case 8400000000ULL:
1384 params->central_freq = 3;
1385 }
1386
1387 switch (p0) {
1388 case 1:
1389 params->pdiv = 0;
1390 break;
1391 case 2:
1392 params->pdiv = 1;
1393 break;
1394 case 3:
1395 params->pdiv = 2;
1396 break;
1397 case 7:
1398 params->pdiv = 4;
1399 break;
1400 default:
1401 WARN(1, "Incorrect PDiv\n");
1402 }
1403
1404 switch (p2) {
1405 case 5:
1406 params->kdiv = 0;
1407 break;
1408 case 2:
1409 params->kdiv = 1;
1410 break;
1411 case 3:
1412 params->kdiv = 2;
1413 break;
1414 case 1:
1415 params->kdiv = 3;
1416 break;
1417 default:
1418 WARN(1, "Incorrect KDiv\n");
1419 }
1420
1421 params->qdiv_ratio = p1;
1422 params->qdiv_mode = (params->qdiv_ratio == 1) ? 0 : 1;
1423
1424 dco_freq = p0 * p1 * p2 * afe_clock;
1425
1426 /*
1427 * Intermediate values are in Hz.
1428 * Divide by MHz to match bsepc
1429 */
1430 params->dco_integer = div_u64(dco_freq, 24 * MHz(1));
1431 params->dco_fraction =
1432 div_u64((div_u64(dco_freq, 24) -
1433 params->dco_integer * MHz(1)) * 0x8000, MHz(1));
1434}
1435
1436static bool
1437skl_ddi_calculate_wrpll(int clock /* in Hz */,
1438 struct skl_wrpll_params *wrpll_params)
1439{
1440 uint64_t afe_clock = clock * 5; /* AFE Clock is 5x Pixel clock */
1441 uint64_t dco_central_freq[3] = {8400000000ULL,
1442 9000000000ULL,
1443 9600000000ULL};
1444 static const int even_dividers[] = { 4, 6, 8, 10, 12, 14, 16, 18, 20,
1445 24, 28, 30, 32, 36, 40, 42, 44,
1446 48, 52, 54, 56, 60, 64, 66, 68,
1447 70, 72, 76, 78, 80, 84, 88, 90,
1448 92, 96, 98 };
1449 static const int odd_dividers[] = { 3, 5, 7, 9, 15, 21, 35 };
1450 static const struct {
1451 const int *list;
1452 int n_dividers;
1453 } dividers[] = {
1454 { even_dividers, ARRAY_SIZE(even_dividers) },
1455 { odd_dividers, ARRAY_SIZE(odd_dividers) },
1456 };
1457 struct skl_wrpll_context ctx;
1458 unsigned int dco, d, i;
1459 unsigned int p0, p1, p2;
1460
1461 skl_wrpll_context_init(&ctx);
1462
1463 for (d = 0; d < ARRAY_SIZE(dividers); d++) {
1464 for (dco = 0; dco < ARRAY_SIZE(dco_central_freq); dco++) {
1465 for (i = 0; i < dividers[d].n_dividers; i++) {
1466 unsigned int p = dividers[d].list[i];
1467 uint64_t dco_freq = p * afe_clock;
1468
1469 skl_wrpll_try_divider(&ctx,
1470 dco_central_freq[dco],
1471 dco_freq,
1472 p);
1473 /*
1474 * Skip the remaining dividers if we're sure to
1475 * have found the definitive divider, we can't
1476 * improve a 0 deviation.
1477 */
1478 if (ctx.min_deviation == 0)
1479 goto skip_remaining_dividers;
1480 }
1481 }
1482
1483skip_remaining_dividers:
1484 /*
1485 * If a solution is found with an even divider, prefer
1486 * this one.
1487 */
1488 if (d == 0 && ctx.p)
1489 break;
1490 }
1491
1492 if (!ctx.p) {
1493 DRM_DEBUG_DRIVER("No valid divider found for %dHz\n", clock);
1494 return false;
1495 }
1496
1497 /*
1498 * gcc incorrectly analyses that these can be used without being
1499 * initialized. To be fair, it's hard to guess.
1500 */
1501 p0 = p1 = p2 = 0;
1502 skl_wrpll_get_multipliers(ctx.p, &p0, &p1, &p2);
1503 skl_wrpll_params_populate(wrpll_params, afe_clock, ctx.central_freq,
1504 p0, p1, p2);
1505
1506 return true;
1507}
1508
1509static bool
1510skl_ddi_pll_select(struct intel_crtc *intel_crtc,
1511 struct intel_crtc_state *crtc_state,
1512 struct intel_encoder *intel_encoder)
1513{
1514 struct intel_shared_dpll *pll;
1515 uint32_t ctrl1, cfgcr1, cfgcr2;
1516 int clock = crtc_state->port_clock;
1517
1518 /*
1519 * See comment in intel_dpll_hw_state to understand why we always use 0
1520 * as the DPLL id in this function.
1521 */
1522
1523 ctrl1 = DPLL_CTRL1_OVERRIDE(0);
1524
1525 if (intel_encoder->type == INTEL_OUTPUT_HDMI) {
1526 struct skl_wrpll_params wrpll_params = { 0, };
1527
1528 ctrl1 |= DPLL_CTRL1_HDMI_MODE(0);
1529
1530 if (!skl_ddi_calculate_wrpll(clock * 1000, &wrpll_params))
1531 return false;
1532
1533 cfgcr1 = DPLL_CFGCR1_FREQ_ENABLE |
1534 DPLL_CFGCR1_DCO_FRACTION(wrpll_params.dco_fraction) |
1535 wrpll_params.dco_integer;
1536
1537 cfgcr2 = DPLL_CFGCR2_QDIV_RATIO(wrpll_params.qdiv_ratio) |
1538 DPLL_CFGCR2_QDIV_MODE(wrpll_params.qdiv_mode) |
1539 DPLL_CFGCR2_KDIV(wrpll_params.kdiv) |
1540 DPLL_CFGCR2_PDIV(wrpll_params.pdiv) |
1541 wrpll_params.central_freq;
1542 } else if (intel_encoder->type == INTEL_OUTPUT_DISPLAYPORT ||
1543 intel_encoder->type == INTEL_OUTPUT_DP_MST) {
1544 switch (crtc_state->port_clock / 2) {
1545 case 81000:
1546 ctrl1 |= DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_810, 0);
1547 break;
1548 case 135000:
1549 ctrl1 |= DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_1350, 0);
1550 break;
1551 case 270000:
1552 ctrl1 |= DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_2700, 0);
1553 break;
1554 }
1555
1556 cfgcr1 = cfgcr2 = 0;
1557 } else if (intel_encoder->type == INTEL_OUTPUT_EDP) {
1558 return true;
1559 } else
1560 return false;
1561
1562 memset(&crtc_state->dpll_hw_state, 0,
1563 sizeof(crtc_state->dpll_hw_state));
1564
1565 crtc_state->dpll_hw_state.ctrl1 = ctrl1;
1566 crtc_state->dpll_hw_state.cfgcr1 = cfgcr1;
1567 crtc_state->dpll_hw_state.cfgcr2 = cfgcr2;
1568
1569 pll = intel_get_shared_dpll(intel_crtc, crtc_state);
1570 if (pll == NULL) {
1571 DRM_DEBUG_DRIVER("failed to find PLL for pipe %c\n",
1572 pipe_name(intel_crtc->pipe));
1573 return false;
1574 }
1575
1576 /* shared DPLL id 0 is DPLL 1 */
1577 crtc_state->ddi_pll_sel = pll->id + 1;
1578
1579 return true;
1580}
1581
1582/* bxt clock parameters */
1583struct bxt_clk_div {
1584 int clock;
1585 uint32_t p1;
1586 uint32_t p2;
1587 uint32_t m2_int;
1588 uint32_t m2_frac;
1589 bool m2_frac_en;
1590 uint32_t n;
1591};
1592
1593/* pre-calculated values for DP linkrates */
1594static const struct bxt_clk_div bxt_dp_clk_val[] = {
1595 {162000, 4, 2, 32, 1677722, 1, 1},
1596 {270000, 4, 1, 27, 0, 0, 1},
1597 {540000, 2, 1, 27, 0, 0, 1},
1598 {216000, 3, 2, 32, 1677722, 1, 1},
1599 {243000, 4, 1, 24, 1258291, 1, 1},
1600 {324000, 4, 1, 32, 1677722, 1, 1},
1601 {432000, 3, 1, 32, 1677722, 1, 1}
1602};
1603
1604static bool
1605bxt_ddi_pll_select(struct intel_crtc *intel_crtc,
1606 struct intel_crtc_state *crtc_state,
1607 struct intel_encoder *intel_encoder)
1608{
1609 struct intel_shared_dpll *pll;
1610 struct bxt_clk_div clk_div = {0};
1611 int vco = 0;
1612 uint32_t prop_coef, int_coef, gain_ctl, targ_cnt;
1613 uint32_t lanestagger;
1614 int clock = crtc_state->port_clock;
1615
1616 if (intel_encoder->type == INTEL_OUTPUT_HDMI) {
1617 intel_clock_t best_clock;
1618
1619 /* Calculate HDMI div */
1620 /*
1621 * FIXME: tie the following calculation into
1622 * i9xx_crtc_compute_clock
1623 */
1624 if (!bxt_find_best_dpll(crtc_state, clock, &best_clock)) {
1625 DRM_DEBUG_DRIVER("no PLL dividers found for clock %d pipe %c\n",
1626 clock, pipe_name(intel_crtc->pipe));
1627 return false;
1628 }
1629
1630 clk_div.p1 = best_clock.p1;
1631 clk_div.p2 = best_clock.p2;
1632 WARN_ON(best_clock.m1 != 2);
1633 clk_div.n = best_clock.n;
1634 clk_div.m2_int = best_clock.m2 >> 22;
1635 clk_div.m2_frac = best_clock.m2 & ((1 << 22) - 1);
1636 clk_div.m2_frac_en = clk_div.m2_frac != 0;
1637
1638 vco = best_clock.vco;
1639 } else if (intel_encoder->type == INTEL_OUTPUT_DISPLAYPORT ||
1640 intel_encoder->type == INTEL_OUTPUT_EDP) {
1641 int i;
1642
1643 clk_div = bxt_dp_clk_val[0];
1644 for (i = 0; i < ARRAY_SIZE(bxt_dp_clk_val); ++i) {
1645 if (bxt_dp_clk_val[i].clock == clock) {
1646 clk_div = bxt_dp_clk_val[i];
1647 break;
1648 }
1649 }
1650 vco = clock * 10 / 2 * clk_div.p1 * clk_div.p2;
1651 }
1652
1653 if (vco >= 6200000 && vco <= 6700000) {
1654 prop_coef = 4;
1655 int_coef = 9;
1656 gain_ctl = 3;
1657 targ_cnt = 8;
1658 } else if ((vco > 5400000 && vco < 6200000) ||
1659 (vco >= 4800000 && vco < 5400000)) {
1660 prop_coef = 5;
1661 int_coef = 11;
1662 gain_ctl = 3;
1663 targ_cnt = 9;
1664 } else if (vco == 5400000) {
1665 prop_coef = 3;
1666 int_coef = 8;
1667 gain_ctl = 1;
1668 targ_cnt = 9;
1669 } else {
1670 DRM_ERROR("Invalid VCO\n");
1671 return false;
1672 }
1673
1674 memset(&crtc_state->dpll_hw_state, 0,
1675 sizeof(crtc_state->dpll_hw_state));
1676
1677 if (clock > 270000)
1678 lanestagger = 0x18;
1679 else if (clock > 135000)
1680 lanestagger = 0x0d;
1681 else if (clock > 67000)
1682 lanestagger = 0x07;
1683 else if (clock > 33000)
1684 lanestagger = 0x04;
1685 else
1686 lanestagger = 0x02;
1687
1688 crtc_state->dpll_hw_state.ebb0 =
1689 PORT_PLL_P1(clk_div.p1) | PORT_PLL_P2(clk_div.p2);
1690 crtc_state->dpll_hw_state.pll0 = clk_div.m2_int;
1691 crtc_state->dpll_hw_state.pll1 = PORT_PLL_N(clk_div.n);
1692 crtc_state->dpll_hw_state.pll2 = clk_div.m2_frac;
1693
1694 if (clk_div.m2_frac_en)
1695 crtc_state->dpll_hw_state.pll3 =
1696 PORT_PLL_M2_FRAC_ENABLE;
1697
1698 crtc_state->dpll_hw_state.pll6 =
1699 prop_coef | PORT_PLL_INT_COEFF(int_coef);
1700 crtc_state->dpll_hw_state.pll6 |=
1701 PORT_PLL_GAIN_CTL(gain_ctl);
1702
1703 crtc_state->dpll_hw_state.pll8 = targ_cnt;
1704
1705 crtc_state->dpll_hw_state.pll9 = 5 << PORT_PLL_LOCK_THRESHOLD_SHIFT;
1706
1707 crtc_state->dpll_hw_state.pll10 =
1708 PORT_PLL_DCO_AMP(PORT_PLL_DCO_AMP_DEFAULT)
1709 | PORT_PLL_DCO_AMP_OVR_EN_H;
1710
1711 crtc_state->dpll_hw_state.ebb4 = PORT_PLL_10BIT_CLK_ENABLE;
1712
1713 crtc_state->dpll_hw_state.pcsdw12 =
1714 LANESTAGGER_STRAP_OVRD | lanestagger;
1715
1716 pll = intel_get_shared_dpll(intel_crtc, crtc_state);
1717 if (pll == NULL) {
1718 DRM_DEBUG_DRIVER("failed to find PLL for pipe %c\n",
1719 pipe_name(intel_crtc->pipe));
1720 return false;
1721 }
1722
1723 /* shared DPLL id 0 is DPLL A */
1724 crtc_state->ddi_pll_sel = pll->id;
1725
1726 return true;
1727}
1728
1729/*
1730 * Tries to find a *shared* PLL for the CRTC and store it in
1731 * intel_crtc->ddi_pll_sel.
1732 *
1733 * For private DPLLs, compute_config() should do the selection for us. This
1734 * function should be folded into compute_config() eventually.
1735 */
1736bool intel_ddi_pll_select(struct intel_crtc *intel_crtc,
1737 struct intel_crtc_state *crtc_state)
1738{
1739 struct drm_device *dev = intel_crtc->base.dev;
1740 struct intel_encoder *intel_encoder =
1741 intel_ddi_get_crtc_new_encoder(crtc_state);
1742
1743 if (IS_SKYLAKE(dev) || IS_KABYLAKE(dev))
1744 return skl_ddi_pll_select(intel_crtc, crtc_state,
1745 intel_encoder);
1746 else if (IS_BROXTON(dev))
1747 return bxt_ddi_pll_select(intel_crtc, crtc_state,
1748 intel_encoder);
1749 else
1750 return hsw_ddi_pll_select(intel_crtc, crtc_state,
1751 intel_encoder);
1752}
1753
1754void intel_ddi_set_pipe_settings(struct drm_crtc *crtc)
1755{
1756 struct drm_i915_private *dev_priv = crtc->dev->dev_private;
1757 struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
1758 struct intel_encoder *intel_encoder = intel_ddi_get_crtc_encoder(crtc);
1759 enum transcoder cpu_transcoder = intel_crtc->config->cpu_transcoder;
1760 int type = intel_encoder->type;
1761 uint32_t temp;
1762
1763 if (type == INTEL_OUTPUT_DISPLAYPORT || type == INTEL_OUTPUT_EDP || type == INTEL_OUTPUT_DP_MST) {
1764 temp = TRANS_MSA_SYNC_CLK;
1765 switch (intel_crtc->config->pipe_bpp) {
1766 case 18:
1767 temp |= TRANS_MSA_6_BPC;
1768 break;
1769 case 24:
1770 temp |= TRANS_MSA_8_BPC;
1771 break;
1772 case 30:
1773 temp |= TRANS_MSA_10_BPC;
1774 break;
1775 case 36:
1776 temp |= TRANS_MSA_12_BPC;
1777 break;
1778 default:
1779 BUG();
1780 }
1781 I915_WRITE(TRANS_MSA_MISC(cpu_transcoder), temp);
1782 }
1783}
1784
1785void intel_ddi_set_vc_payload_alloc(struct drm_crtc *crtc, bool state)
1786{
1787 struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
1788 struct drm_device *dev = crtc->dev;
1789 struct drm_i915_private *dev_priv = dev->dev_private;
1790 enum transcoder cpu_transcoder = intel_crtc->config->cpu_transcoder;
1791 uint32_t temp;
1792 temp = I915_READ(TRANS_DDI_FUNC_CTL(cpu_transcoder));
1793 if (state == true)
1794 temp |= TRANS_DDI_DP_VC_PAYLOAD_ALLOC;
1795 else
1796 temp &= ~TRANS_DDI_DP_VC_PAYLOAD_ALLOC;
1797 I915_WRITE(TRANS_DDI_FUNC_CTL(cpu_transcoder), temp);
1798}
1799
1800void intel_ddi_enable_transcoder_func(struct drm_crtc *crtc)
1801{
1802 struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
1803 struct intel_encoder *intel_encoder = intel_ddi_get_crtc_encoder(crtc);
1804 struct drm_encoder *encoder = &intel_encoder->base;
1805 struct drm_device *dev = crtc->dev;
1806 struct drm_i915_private *dev_priv = dev->dev_private;
1807 enum pipe pipe = intel_crtc->pipe;
1808 enum transcoder cpu_transcoder = intel_crtc->config->cpu_transcoder;
1809 enum port port = intel_ddi_get_encoder_port(intel_encoder);
1810 int type = intel_encoder->type;
1811 uint32_t temp;
1812
1813 /* Enable TRANS_DDI_FUNC_CTL for the pipe to work in HDMI mode */
1814 temp = TRANS_DDI_FUNC_ENABLE;
1815 temp |= TRANS_DDI_SELECT_PORT(port);
1816
1817 switch (intel_crtc->config->pipe_bpp) {
1818 case 18:
1819 temp |= TRANS_DDI_BPC_6;
1820 break;
1821 case 24:
1822 temp |= TRANS_DDI_BPC_8;
1823 break;
1824 case 30:
1825 temp |= TRANS_DDI_BPC_10;
1826 break;
1827 case 36:
1828 temp |= TRANS_DDI_BPC_12;
1829 break;
1830 default:
1831 BUG();
1832 }
1833
1834 if (intel_crtc->config->base.adjusted_mode.flags & DRM_MODE_FLAG_PVSYNC)
1835 temp |= TRANS_DDI_PVSYNC;
1836 if (intel_crtc->config->base.adjusted_mode.flags & DRM_MODE_FLAG_PHSYNC)
1837 temp |= TRANS_DDI_PHSYNC;
1838
1839 if (cpu_transcoder == TRANSCODER_EDP) {
1840 switch (pipe) {
1841 case PIPE_A:
1842 /* On Haswell, can only use the always-on power well for
1843 * eDP when not using the panel fitter, and when not
1844 * using motion blur mitigation (which we don't
1845 * support). */
1846 if (IS_HASWELL(dev) &&
1847 (intel_crtc->config->pch_pfit.enabled ||
1848 intel_crtc->config->pch_pfit.force_thru))
1849 temp |= TRANS_DDI_EDP_INPUT_A_ONOFF;
1850 else
1851 temp |= TRANS_DDI_EDP_INPUT_A_ON;
1852 break;
1853 case PIPE_B:
1854 temp |= TRANS_DDI_EDP_INPUT_B_ONOFF;
1855 break;
1856 case PIPE_C:
1857 temp |= TRANS_DDI_EDP_INPUT_C_ONOFF;
1858 break;
1859 default:
1860 BUG();
1861 break;
1862 }
1863 }
1864
1865 if (type == INTEL_OUTPUT_HDMI) {
1866 if (intel_crtc->config->has_hdmi_sink)
1867 temp |= TRANS_DDI_MODE_SELECT_HDMI;
1868 else
1869 temp |= TRANS_DDI_MODE_SELECT_DVI;
1870
1871 } else if (type == INTEL_OUTPUT_ANALOG) {
1872 temp |= TRANS_DDI_MODE_SELECT_FDI;
1873 temp |= (intel_crtc->config->fdi_lanes - 1) << 1;
1874
1875 } else if (type == INTEL_OUTPUT_DISPLAYPORT ||
1876 type == INTEL_OUTPUT_EDP) {
1877 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
1878
1879 if (intel_dp->is_mst) {
1880 temp |= TRANS_DDI_MODE_SELECT_DP_MST;
1881 } else
1882 temp |= TRANS_DDI_MODE_SELECT_DP_SST;
1883
1884 temp |= DDI_PORT_WIDTH(intel_crtc->config->lane_count);
1885 } else if (type == INTEL_OUTPUT_DP_MST) {
1886 struct intel_dp *intel_dp = &enc_to_mst(encoder)->primary->dp;
1887
1888 if (intel_dp->is_mst) {
1889 temp |= TRANS_DDI_MODE_SELECT_DP_MST;
1890 } else
1891 temp |= TRANS_DDI_MODE_SELECT_DP_SST;
1892
1893 temp |= DDI_PORT_WIDTH(intel_crtc->config->lane_count);
1894 } else {
1895 WARN(1, "Invalid encoder type %d for pipe %c\n",
1896 intel_encoder->type, pipe_name(pipe));
1897 }
1898
1899 I915_WRITE(TRANS_DDI_FUNC_CTL(cpu_transcoder), temp);
1900}
1901
1902void intel_ddi_disable_transcoder_func(struct drm_i915_private *dev_priv,
1903 enum transcoder cpu_transcoder)
1904{
1905 i915_reg_t reg = TRANS_DDI_FUNC_CTL(cpu_transcoder);
1906 uint32_t val = I915_READ(reg);
1907
1908 val &= ~(TRANS_DDI_FUNC_ENABLE | TRANS_DDI_PORT_MASK | TRANS_DDI_DP_VC_PAYLOAD_ALLOC);
1909 val |= TRANS_DDI_PORT_NONE;
1910 I915_WRITE(reg, val);
1911}
1912
1913bool intel_ddi_connector_get_hw_state(struct intel_connector *intel_connector)
1914{
1915 struct drm_device *dev = intel_connector->base.dev;
1916 struct drm_i915_private *dev_priv = dev->dev_private;
1917 struct intel_encoder *intel_encoder = intel_connector->encoder;
1918 int type = intel_connector->base.connector_type;
1919 enum port port = intel_ddi_get_encoder_port(intel_encoder);
1920 enum pipe pipe = 0;
1921 enum transcoder cpu_transcoder;
1922 enum intel_display_power_domain power_domain;
1923 uint32_t tmp;
1924 bool ret;
1925
1926 power_domain = intel_display_port_power_domain(intel_encoder);
1927 if (!intel_display_power_get_if_enabled(dev_priv, power_domain))
1928 return false;
1929
1930 if (!intel_encoder->get_hw_state(intel_encoder, &pipe)) {
1931 ret = false;
1932 goto out;
1933 }
1934
1935 if (port == PORT_A)
1936 cpu_transcoder = TRANSCODER_EDP;
1937 else
1938 cpu_transcoder = (enum transcoder) pipe;
1939
1940 tmp = I915_READ(TRANS_DDI_FUNC_CTL(cpu_transcoder));
1941
1942 switch (tmp & TRANS_DDI_MODE_SELECT_MASK) {
1943 case TRANS_DDI_MODE_SELECT_HDMI:
1944 case TRANS_DDI_MODE_SELECT_DVI:
1945 ret = type == DRM_MODE_CONNECTOR_HDMIA;
1946 break;
1947
1948 case TRANS_DDI_MODE_SELECT_DP_SST:
1949 ret = type == DRM_MODE_CONNECTOR_eDP ||
1950 type == DRM_MODE_CONNECTOR_DisplayPort;
1951 break;
1952
1953 case TRANS_DDI_MODE_SELECT_DP_MST:
1954 /* if the transcoder is in MST state then
1955 * connector isn't connected */
1956 ret = false;
1957 break;
1958
1959 case TRANS_DDI_MODE_SELECT_FDI:
1960 ret = type == DRM_MODE_CONNECTOR_VGA;
1961 break;
1962
1963 default:
1964 ret = false;
1965 break;
1966 }
1967
1968out:
1969 intel_display_power_put(dev_priv, power_domain);
1970
1971 return ret;
1972}
1973
1974bool intel_ddi_get_hw_state(struct intel_encoder *encoder,
1975 enum pipe *pipe)
1976{
1977 struct drm_device *dev = encoder->base.dev;
1978 struct drm_i915_private *dev_priv = dev->dev_private;
1979 enum port port = intel_ddi_get_encoder_port(encoder);
1980 enum intel_display_power_domain power_domain;
1981 u32 tmp;
1982 int i;
1983 bool ret;
1984
1985 power_domain = intel_display_port_power_domain(encoder);
1986 if (!intel_display_power_get_if_enabled(dev_priv, power_domain))
1987 return false;
1988
1989 ret = false;
1990
1991 tmp = I915_READ(DDI_BUF_CTL(port));
1992
1993 if (!(tmp & DDI_BUF_CTL_ENABLE))
1994 goto out;
1995
1996 if (port == PORT_A) {
1997 tmp = I915_READ(TRANS_DDI_FUNC_CTL(TRANSCODER_EDP));
1998
1999 switch (tmp & TRANS_DDI_EDP_INPUT_MASK) {
2000 case TRANS_DDI_EDP_INPUT_A_ON:
2001 case TRANS_DDI_EDP_INPUT_A_ONOFF:
2002 *pipe = PIPE_A;
2003 break;
2004 case TRANS_DDI_EDP_INPUT_B_ONOFF:
2005 *pipe = PIPE_B;
2006 break;
2007 case TRANS_DDI_EDP_INPUT_C_ONOFF:
2008 *pipe = PIPE_C;
2009 break;
2010 }
2011
2012 ret = true;
2013
2014 goto out;
2015 }
2016
2017 for (i = TRANSCODER_A; i <= TRANSCODER_C; i++) {
2018 tmp = I915_READ(TRANS_DDI_FUNC_CTL(i));
2019
2020 if ((tmp & TRANS_DDI_PORT_MASK) == TRANS_DDI_SELECT_PORT(port)) {
2021 if ((tmp & TRANS_DDI_MODE_SELECT_MASK) ==
2022 TRANS_DDI_MODE_SELECT_DP_MST)
2023 goto out;
2024
2025 *pipe = i;
2026 ret = true;
2027
2028 goto out;
2029 }
2030 }
2031
2032 DRM_DEBUG_KMS("No pipe for ddi port %c found\n", port_name(port));
2033
2034out:
2035 intel_display_power_put(dev_priv, power_domain);
2036
2037 return ret;
2038}
2039
2040void intel_ddi_enable_pipe_clock(struct intel_crtc *intel_crtc)
2041{
2042 struct drm_crtc *crtc = &intel_crtc->base;
2043 struct drm_device *dev = crtc->dev;
2044 struct drm_i915_private *dev_priv = dev->dev_private;
2045 struct intel_encoder *intel_encoder = intel_ddi_get_crtc_encoder(crtc);
2046 enum port port = intel_ddi_get_encoder_port(intel_encoder);
2047 enum transcoder cpu_transcoder = intel_crtc->config->cpu_transcoder;
2048
2049 if (cpu_transcoder != TRANSCODER_EDP)
2050 I915_WRITE(TRANS_CLK_SEL(cpu_transcoder),
2051 TRANS_CLK_SEL_PORT(port));
2052}
2053
2054void intel_ddi_disable_pipe_clock(struct intel_crtc *intel_crtc)
2055{
2056 struct drm_i915_private *dev_priv = intel_crtc->base.dev->dev_private;
2057 enum transcoder cpu_transcoder = intel_crtc->config->cpu_transcoder;
2058
2059 if (cpu_transcoder != TRANSCODER_EDP)
2060 I915_WRITE(TRANS_CLK_SEL(cpu_transcoder),
2061 TRANS_CLK_SEL_DISABLED);
2062}
2063
2064static void skl_ddi_set_iboost(struct drm_i915_private *dev_priv,
2065 u32 level, enum port port, int type)
2066{
2067 const struct ddi_buf_trans *ddi_translations;
2068 uint8_t iboost;
2069 uint8_t dp_iboost, hdmi_iboost;
2070 int n_entries;
2071 u32 reg;
2072
2073 /* VBT may override standard boost values */
2074 dp_iboost = dev_priv->vbt.ddi_port_info[port].dp_boost_level;
2075 hdmi_iboost = dev_priv->vbt.ddi_port_info[port].hdmi_boost_level;
2076
2077 if (type == INTEL_OUTPUT_DISPLAYPORT) {
2078 if (dp_iboost) {
2079 iboost = dp_iboost;
2080 } else {
2081 ddi_translations = skl_get_buf_trans_dp(dev_priv, &n_entries);
2082 iboost = ddi_translations[level].i_boost;
2083 }
2084 } else if (type == INTEL_OUTPUT_EDP) {
2085 if (dp_iboost) {
2086 iboost = dp_iboost;
2087 } else {
2088 ddi_translations = skl_get_buf_trans_edp(dev_priv, &n_entries);
2089
2090 if (WARN_ON(port != PORT_A &&
2091 port != PORT_E && n_entries > 9))
2092 n_entries = 9;
2093
2094 iboost = ddi_translations[level].i_boost;
2095 }
2096 } else if (type == INTEL_OUTPUT_HDMI) {
2097 if (hdmi_iboost) {
2098 iboost = hdmi_iboost;
2099 } else {
2100 ddi_translations = skl_get_buf_trans_hdmi(dev_priv, &n_entries);
2101 iboost = ddi_translations[level].i_boost;
2102 }
2103 } else {
2104 return;
2105 }
2106
2107 /* Make sure that the requested I_boost is valid */
2108 if (iboost && iboost != 0x1 && iboost != 0x3 && iboost != 0x7) {
2109 DRM_ERROR("Invalid I_boost value %u\n", iboost);
2110 return;
2111 }
2112
2113 reg = I915_READ(DISPIO_CR_TX_BMU_CR0);
2114 reg &= ~BALANCE_LEG_MASK(port);
2115 reg &= ~(1 << (BALANCE_LEG_DISABLE_SHIFT + port));
2116
2117 if (iboost)
2118 reg |= iboost << BALANCE_LEG_SHIFT(port);
2119 else
2120 reg |= 1 << (BALANCE_LEG_DISABLE_SHIFT + port);
2121
2122 I915_WRITE(DISPIO_CR_TX_BMU_CR0, reg);
2123}
2124
2125static void bxt_ddi_vswing_sequence(struct drm_i915_private *dev_priv,
2126 u32 level, enum port port, int type)
2127{
2128 const struct bxt_ddi_buf_trans *ddi_translations;
2129 u32 n_entries, i;
2130 uint32_t val;
2131
2132 if (type == INTEL_OUTPUT_EDP && dev_priv->edp_low_vswing) {
2133 n_entries = ARRAY_SIZE(bxt_ddi_translations_edp);
2134 ddi_translations = bxt_ddi_translations_edp;
2135 } else if (type == INTEL_OUTPUT_DISPLAYPORT
2136 || type == INTEL_OUTPUT_EDP) {
2137 n_entries = ARRAY_SIZE(bxt_ddi_translations_dp);
2138 ddi_translations = bxt_ddi_translations_dp;
2139 } else if (type == INTEL_OUTPUT_HDMI) {
2140 n_entries = ARRAY_SIZE(bxt_ddi_translations_hdmi);
2141 ddi_translations = bxt_ddi_translations_hdmi;
2142 } else {
2143 DRM_DEBUG_KMS("Vswing programming not done for encoder %d\n",
2144 type);
2145 return;
2146 }
2147
2148 /* Check if default value has to be used */
2149 if (level >= n_entries ||
2150 (type == INTEL_OUTPUT_HDMI && level == HDMI_LEVEL_SHIFT_UNKNOWN)) {
2151 for (i = 0; i < n_entries; i++) {
2152 if (ddi_translations[i].default_index) {
2153 level = i;
2154 break;
2155 }
2156 }
2157 }
2158
2159 /*
2160 * While we write to the group register to program all lanes at once we
2161 * can read only lane registers and we pick lanes 0/1 for that.
2162 */
2163 val = I915_READ(BXT_PORT_PCS_DW10_LN01(port));
2164 val &= ~(TX2_SWING_CALC_INIT | TX1_SWING_CALC_INIT);
2165 I915_WRITE(BXT_PORT_PCS_DW10_GRP(port), val);
2166
2167 val = I915_READ(BXT_PORT_TX_DW2_LN0(port));
2168 val &= ~(MARGIN_000 | UNIQ_TRANS_SCALE);
2169 val |= ddi_translations[level].margin << MARGIN_000_SHIFT |
2170 ddi_translations[level].scale << UNIQ_TRANS_SCALE_SHIFT;
2171 I915_WRITE(BXT_PORT_TX_DW2_GRP(port), val);
2172
2173 val = I915_READ(BXT_PORT_TX_DW3_LN0(port));
2174 val &= ~SCALE_DCOMP_METHOD;
2175 if (ddi_translations[level].enable)
2176 val |= SCALE_DCOMP_METHOD;
2177
2178 if ((val & UNIQUE_TRANGE_EN_METHOD) && !(val & SCALE_DCOMP_METHOD))
2179 DRM_ERROR("Disabled scaling while ouniqetrangenmethod was set");
2180
2181 I915_WRITE(BXT_PORT_TX_DW3_GRP(port), val);
2182
2183 val = I915_READ(BXT_PORT_TX_DW4_LN0(port));
2184 val &= ~DE_EMPHASIS;
2185 val |= ddi_translations[level].deemphasis << DEEMPH_SHIFT;
2186 I915_WRITE(BXT_PORT_TX_DW4_GRP(port), val);
2187
2188 val = I915_READ(BXT_PORT_PCS_DW10_LN01(port));
2189 val |= TX2_SWING_CALC_INIT | TX1_SWING_CALC_INIT;
2190 I915_WRITE(BXT_PORT_PCS_DW10_GRP(port), val);
2191}
2192
2193static uint32_t translate_signal_level(int signal_levels)
2194{
2195 uint32_t level;
2196
2197 switch (signal_levels) {
2198 default:
2199 DRM_DEBUG_KMS("Unsupported voltage swing/pre-emphasis level: 0x%x\n",
2200 signal_levels);
2201 case DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_0:
2202 level = 0;
2203 break;
2204 case DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_1:
2205 level = 1;
2206 break;
2207 case DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_2:
2208 level = 2;
2209 break;
2210 case DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_3:
2211 level = 3;
2212 break;
2213
2214 case DP_TRAIN_VOLTAGE_SWING_LEVEL_1 | DP_TRAIN_PRE_EMPH_LEVEL_0:
2215 level = 4;
2216 break;
2217 case DP_TRAIN_VOLTAGE_SWING_LEVEL_1 | DP_TRAIN_PRE_EMPH_LEVEL_1:
2218 level = 5;
2219 break;
2220 case DP_TRAIN_VOLTAGE_SWING_LEVEL_1 | DP_TRAIN_PRE_EMPH_LEVEL_2:
2221 level = 6;
2222 break;
2223
2224 case DP_TRAIN_VOLTAGE_SWING_LEVEL_2 | DP_TRAIN_PRE_EMPH_LEVEL_0:
2225 level = 7;
2226 break;
2227 case DP_TRAIN_VOLTAGE_SWING_LEVEL_2 | DP_TRAIN_PRE_EMPH_LEVEL_1:
2228 level = 8;
2229 break;
2230
2231 case DP_TRAIN_VOLTAGE_SWING_LEVEL_3 | DP_TRAIN_PRE_EMPH_LEVEL_0:
2232 level = 9;
2233 break;
2234 }
2235
2236 return level;
2237}
2238
2239uint32_t ddi_signal_levels(struct intel_dp *intel_dp)
2240{
2241 struct intel_digital_port *dport = dp_to_dig_port(intel_dp);
2242 struct drm_i915_private *dev_priv = to_i915(dport->base.base.dev);
2243 struct intel_encoder *encoder = &dport->base;
2244 uint8_t train_set = intel_dp->train_set[0];
2245 int signal_levels = train_set & (DP_TRAIN_VOLTAGE_SWING_MASK |
2246 DP_TRAIN_PRE_EMPHASIS_MASK);
2247 enum port port = dport->port;
2248 uint32_t level;
2249
2250 level = translate_signal_level(signal_levels);
2251
2252 if (IS_SKYLAKE(dev_priv) || IS_KABYLAKE(dev_priv))
2253 skl_ddi_set_iboost(dev_priv, level, port, encoder->type);
2254 else if (IS_BROXTON(dev_priv))
2255 bxt_ddi_vswing_sequence(dev_priv, level, port, encoder->type);
2256
2257 return DDI_BUF_TRANS_SELECT(level);
2258}
2259
2260void intel_ddi_clk_select(struct intel_encoder *encoder,
2261 const struct intel_crtc_state *pipe_config)
2262{
2263 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2264 enum port port = intel_ddi_get_encoder_port(encoder);
2265
2266 if (IS_SKYLAKE(dev_priv) || IS_KABYLAKE(dev_priv)) {
2267 uint32_t dpll = pipe_config->ddi_pll_sel;
2268 uint32_t val;
2269
2270 /*
2271 * DPLL0 is used for eDP and is the only "private" DPLL (as
2272 * opposed to shared) on SKL
2273 */
2274 if (encoder->type == INTEL_OUTPUT_EDP) {
2275 WARN_ON(dpll != SKL_DPLL0);
2276
2277 val = I915_READ(DPLL_CTRL1);
2278
2279 val &= ~(DPLL_CTRL1_HDMI_MODE(dpll) |
2280 DPLL_CTRL1_SSC(dpll) |
2281 DPLL_CTRL1_LINK_RATE_MASK(dpll));
2282 val |= pipe_config->dpll_hw_state.ctrl1 << (dpll * 6);
2283
2284 I915_WRITE(DPLL_CTRL1, val);
2285 POSTING_READ(DPLL_CTRL1);
2286 }
2287
2288 /* DDI -> PLL mapping */
2289 val = I915_READ(DPLL_CTRL2);
2290
2291 val &= ~(DPLL_CTRL2_DDI_CLK_OFF(port) |
2292 DPLL_CTRL2_DDI_CLK_SEL_MASK(port));
2293 val |= (DPLL_CTRL2_DDI_CLK_SEL(dpll, port) |
2294 DPLL_CTRL2_DDI_SEL_OVERRIDE(port));
2295
2296 I915_WRITE(DPLL_CTRL2, val);
2297
2298 } else if (INTEL_INFO(dev_priv)->gen < 9) {
2299 WARN_ON(pipe_config->ddi_pll_sel == PORT_CLK_SEL_NONE);
2300 I915_WRITE(PORT_CLK_SEL(port), pipe_config->ddi_pll_sel);
2301 }
2302}
2303
2304static void intel_ddi_pre_enable(struct intel_encoder *intel_encoder)
2305{
2306 struct drm_encoder *encoder = &intel_encoder->base;
2307 struct drm_i915_private *dev_priv = to_i915(encoder->dev);
2308 struct intel_crtc *crtc = to_intel_crtc(encoder->crtc);
2309 enum port port = intel_ddi_get_encoder_port(intel_encoder);
2310 int type = intel_encoder->type;
2311
2312 intel_prepare_ddi_buffer(intel_encoder);
2313
2314 if (type == INTEL_OUTPUT_EDP) {
2315 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
2316 intel_edp_panel_on(intel_dp);
2317 }
2318
2319 intel_ddi_clk_select(intel_encoder, crtc->config);
2320
2321 if (type == INTEL_OUTPUT_DISPLAYPORT || type == INTEL_OUTPUT_EDP) {
2322 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
2323
2324 intel_dp_set_link_params(intel_dp, crtc->config);
2325
2326 intel_ddi_init_dp_buf_reg(intel_encoder);
2327
2328 intel_dp_sink_dpms(intel_dp, DRM_MODE_DPMS_ON);
2329 intel_dp_start_link_train(intel_dp);
2330 if (port != PORT_A || INTEL_INFO(dev_priv)->gen >= 9)
2331 intel_dp_stop_link_train(intel_dp);
2332 } else if (type == INTEL_OUTPUT_HDMI) {
2333 struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(encoder);
2334
2335 intel_hdmi->set_infoframes(encoder,
2336 crtc->config->has_hdmi_sink,
2337 &crtc->config->base.adjusted_mode);
2338 }
2339}
2340
2341static void intel_ddi_post_disable(struct intel_encoder *intel_encoder)
2342{
2343 struct drm_encoder *encoder = &intel_encoder->base;
2344 struct drm_device *dev = encoder->dev;
2345 struct drm_i915_private *dev_priv = dev->dev_private;
2346 enum port port = intel_ddi_get_encoder_port(intel_encoder);
2347 int type = intel_encoder->type;
2348 uint32_t val;
2349 bool wait = false;
2350
2351 val = I915_READ(DDI_BUF_CTL(port));
2352 if (val & DDI_BUF_CTL_ENABLE) {
2353 val &= ~DDI_BUF_CTL_ENABLE;
2354 I915_WRITE(DDI_BUF_CTL(port), val);
2355 wait = true;
2356 }
2357
2358 val = I915_READ(DP_TP_CTL(port));
2359 val &= ~(DP_TP_CTL_ENABLE | DP_TP_CTL_LINK_TRAIN_MASK);
2360 val |= DP_TP_CTL_LINK_TRAIN_PAT1;
2361 I915_WRITE(DP_TP_CTL(port), val);
2362
2363 if (wait)
2364 intel_wait_ddi_buf_idle(dev_priv, port);
2365
2366 if (type == INTEL_OUTPUT_DISPLAYPORT || type == INTEL_OUTPUT_EDP) {
2367 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
2368 intel_dp_sink_dpms(intel_dp, DRM_MODE_DPMS_OFF);
2369 intel_edp_panel_vdd_on(intel_dp);
2370 intel_edp_panel_off(intel_dp);
2371 }
2372
2373 if (IS_SKYLAKE(dev) || IS_KABYLAKE(dev))
2374 I915_WRITE(DPLL_CTRL2, (I915_READ(DPLL_CTRL2) |
2375 DPLL_CTRL2_DDI_CLK_OFF(port)));
2376 else if (INTEL_INFO(dev)->gen < 9)
2377 I915_WRITE(PORT_CLK_SEL(port), PORT_CLK_SEL_NONE);
2378}
2379
2380static void intel_enable_ddi(struct intel_encoder *intel_encoder)
2381{
2382 struct drm_encoder *encoder = &intel_encoder->base;
2383 struct drm_crtc *crtc = encoder->crtc;
2384 struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
2385 struct drm_device *dev = encoder->dev;
2386 struct drm_i915_private *dev_priv = dev->dev_private;
2387 enum port port = intel_ddi_get_encoder_port(intel_encoder);
2388 int type = intel_encoder->type;
2389
2390 if (type == INTEL_OUTPUT_HDMI) {
2391 struct intel_digital_port *intel_dig_port =
2392 enc_to_dig_port(encoder);
2393
2394 /* In HDMI/DVI mode, the port width, and swing/emphasis values
2395 * are ignored so nothing special needs to be done besides
2396 * enabling the port.
2397 */
2398 I915_WRITE(DDI_BUF_CTL(port),
2399 intel_dig_port->saved_port_bits |
2400 DDI_BUF_CTL_ENABLE);
2401 } else if (type == INTEL_OUTPUT_EDP) {
2402 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
2403
2404 if (port == PORT_A && INTEL_INFO(dev)->gen < 9)
2405 intel_dp_stop_link_train(intel_dp);
2406
2407 intel_edp_backlight_on(intel_dp);
2408 intel_psr_enable(intel_dp);
2409 intel_edp_drrs_enable(intel_dp);
2410 }
2411
2412 if (intel_crtc->config->has_audio) {
2413 intel_display_power_get(dev_priv, POWER_DOMAIN_AUDIO);
2414 intel_audio_codec_enable(intel_encoder);
2415 }
2416}
2417
2418static void intel_disable_ddi(struct intel_encoder *intel_encoder)
2419{
2420 struct drm_encoder *encoder = &intel_encoder->base;
2421 struct drm_crtc *crtc = encoder->crtc;
2422 struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
2423 int type = intel_encoder->type;
2424 struct drm_device *dev = encoder->dev;
2425 struct drm_i915_private *dev_priv = dev->dev_private;
2426
2427 if (intel_crtc->config->has_audio) {
2428 intel_audio_codec_disable(intel_encoder);
2429 intel_display_power_put(dev_priv, POWER_DOMAIN_AUDIO);
2430 }
2431
2432 if (type == INTEL_OUTPUT_EDP) {
2433 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
2434
2435 intel_edp_drrs_disable(intel_dp);
2436 intel_psr_disable(intel_dp);
2437 intel_edp_backlight_off(intel_dp);
2438 }
2439}
2440
2441static void hsw_ddi_wrpll_enable(struct drm_i915_private *dev_priv,
2442 struct intel_shared_dpll *pll)
2443{
2444 I915_WRITE(WRPLL_CTL(pll->id), pll->config.hw_state.wrpll);
2445 POSTING_READ(WRPLL_CTL(pll->id));
2446 udelay(20);
2447}
2448
2449static void hsw_ddi_spll_enable(struct drm_i915_private *dev_priv,
2450 struct intel_shared_dpll *pll)
2451{
2452 I915_WRITE(SPLL_CTL, pll->config.hw_state.spll);
2453 POSTING_READ(SPLL_CTL);
2454 udelay(20);
2455}
2456
2457static void hsw_ddi_wrpll_disable(struct drm_i915_private *dev_priv,
2458 struct intel_shared_dpll *pll)
2459{
2460 uint32_t val;
2461
2462 val = I915_READ(WRPLL_CTL(pll->id));
2463 I915_WRITE(WRPLL_CTL(pll->id), val & ~WRPLL_PLL_ENABLE);
2464 POSTING_READ(WRPLL_CTL(pll->id));
2465}
2466
2467static void hsw_ddi_spll_disable(struct drm_i915_private *dev_priv,
2468 struct intel_shared_dpll *pll)
2469{
2470 uint32_t val;
2471
2472 val = I915_READ(SPLL_CTL);
2473 I915_WRITE(SPLL_CTL, val & ~SPLL_PLL_ENABLE);
2474 POSTING_READ(SPLL_CTL);
2475}
2476
2477static bool hsw_ddi_wrpll_get_hw_state(struct drm_i915_private *dev_priv,
2478 struct intel_shared_dpll *pll,
2479 struct intel_dpll_hw_state *hw_state)
2480{
2481 uint32_t val;
2482
2483 if (!intel_display_power_get_if_enabled(dev_priv, POWER_DOMAIN_PLLS))
2484 return false;
2485
2486 val = I915_READ(WRPLL_CTL(pll->id));
2487 hw_state->wrpll = val;
2488
2489 intel_display_power_put(dev_priv, POWER_DOMAIN_PLLS);
2490
2491 return val & WRPLL_PLL_ENABLE;
2492}
2493
2494static bool hsw_ddi_spll_get_hw_state(struct drm_i915_private *dev_priv,
2495 struct intel_shared_dpll *pll,
2496 struct intel_dpll_hw_state *hw_state)
2497{
2498 uint32_t val;
2499
2500 if (!intel_display_power_get_if_enabled(dev_priv, POWER_DOMAIN_PLLS))
2501 return false;
2502
2503 val = I915_READ(SPLL_CTL);
2504 hw_state->spll = val;
2505
2506 intel_display_power_put(dev_priv, POWER_DOMAIN_PLLS);
2507
2508 return val & SPLL_PLL_ENABLE;
2509}
2510
2511
2512static const char * const hsw_ddi_pll_names[] = {
2513 "WRPLL 1",
2514 "WRPLL 2",
2515 "SPLL"
2516};
2517
2518static void hsw_shared_dplls_init(struct drm_i915_private *dev_priv)
2519{
2520 int i;
2521
2522 dev_priv->num_shared_dpll = 3;
2523
2524 for (i = 0; i < 2; i++) {
2525 dev_priv->shared_dplls[i].id = i;
2526 dev_priv->shared_dplls[i].name = hsw_ddi_pll_names[i];
2527 dev_priv->shared_dplls[i].disable = hsw_ddi_wrpll_disable;
2528 dev_priv->shared_dplls[i].enable = hsw_ddi_wrpll_enable;
2529 dev_priv->shared_dplls[i].get_hw_state =
2530 hsw_ddi_wrpll_get_hw_state;
2531 }
2532
2533 /* SPLL is special, but needs to be initialized anyway.. */
2534 dev_priv->shared_dplls[i].id = i;
2535 dev_priv->shared_dplls[i].name = hsw_ddi_pll_names[i];
2536 dev_priv->shared_dplls[i].disable = hsw_ddi_spll_disable;
2537 dev_priv->shared_dplls[i].enable = hsw_ddi_spll_enable;
2538 dev_priv->shared_dplls[i].get_hw_state = hsw_ddi_spll_get_hw_state;
2539
2540}
2541
2542static const char * const skl_ddi_pll_names[] = {
2543 "DPLL 1",
2544 "DPLL 2",
2545 "DPLL 3",
2546};
2547
2548struct skl_dpll_regs {
2549 i915_reg_t ctl, cfgcr1, cfgcr2;
2550};
2551
2552/* this array is indexed by the *shared* pll id */
2553static const struct skl_dpll_regs skl_dpll_regs[3] = {
2554 {
2555 /* DPLL 1 */
2556 .ctl = LCPLL2_CTL,
2557 .cfgcr1 = DPLL_CFGCR1(SKL_DPLL1),
2558 .cfgcr2 = DPLL_CFGCR2(SKL_DPLL1),
2559 },
2560 {
2561 /* DPLL 2 */
2562 .ctl = WRPLL_CTL(0),
2563 .cfgcr1 = DPLL_CFGCR1(SKL_DPLL2),
2564 .cfgcr2 = DPLL_CFGCR2(SKL_DPLL2),
2565 },
2566 {
2567 /* DPLL 3 */
2568 .ctl = WRPLL_CTL(1),
2569 .cfgcr1 = DPLL_CFGCR1(SKL_DPLL3),
2570 .cfgcr2 = DPLL_CFGCR2(SKL_DPLL3),
2571 },
2572};
2573
2574static void skl_ddi_pll_enable(struct drm_i915_private *dev_priv,
2575 struct intel_shared_dpll *pll)
2576{
2577 uint32_t val;
2578 unsigned int dpll;
2579 const struct skl_dpll_regs *regs = skl_dpll_regs;
2580
2581 /* DPLL0 is not part of the shared DPLLs, so pll->id is 0 for DPLL1 */
2582 dpll = pll->id + 1;
2583
2584 val = I915_READ(DPLL_CTRL1);
2585
2586 val &= ~(DPLL_CTRL1_HDMI_MODE(dpll) | DPLL_CTRL1_SSC(dpll) |
2587 DPLL_CTRL1_LINK_RATE_MASK(dpll));
2588 val |= pll->config.hw_state.ctrl1 << (dpll * 6);
2589
2590 I915_WRITE(DPLL_CTRL1, val);
2591 POSTING_READ(DPLL_CTRL1);
2592
2593 I915_WRITE(regs[pll->id].cfgcr1, pll->config.hw_state.cfgcr1);
2594 I915_WRITE(regs[pll->id].cfgcr2, pll->config.hw_state.cfgcr2);
2595 POSTING_READ(regs[pll->id].cfgcr1);
2596 POSTING_READ(regs[pll->id].cfgcr2);
2597
2598 /* the enable bit is always bit 31 */
2599 I915_WRITE(regs[pll->id].ctl,
2600 I915_READ(regs[pll->id].ctl) | LCPLL_PLL_ENABLE);
2601
2602 if (wait_for(I915_READ(DPLL_STATUS) & DPLL_LOCK(dpll), 5))
2603 DRM_ERROR("DPLL %d not locked\n", dpll);
2604}
2605
2606static void skl_ddi_pll_disable(struct drm_i915_private *dev_priv,
2607 struct intel_shared_dpll *pll)
2608{
2609 const struct skl_dpll_regs *regs = skl_dpll_regs;
2610
2611 /* the enable bit is always bit 31 */
2612 I915_WRITE(regs[pll->id].ctl,
2613 I915_READ(regs[pll->id].ctl) & ~LCPLL_PLL_ENABLE);
2614 POSTING_READ(regs[pll->id].ctl);
2615}
2616
2617static bool skl_ddi_pll_get_hw_state(struct drm_i915_private *dev_priv,
2618 struct intel_shared_dpll *pll,
2619 struct intel_dpll_hw_state *hw_state)
2620{
2621 uint32_t val;
2622 unsigned int dpll;
2623 const struct skl_dpll_regs *regs = skl_dpll_regs;
2624 bool ret;
2625
2626 if (!intel_display_power_get_if_enabled(dev_priv, POWER_DOMAIN_PLLS))
2627 return false;
2628
2629 ret = false;
2630
2631 /* DPLL0 is not part of the shared DPLLs, so pll->id is 0 for DPLL1 */
2632 dpll = pll->id + 1;
2633
2634 val = I915_READ(regs[pll->id].ctl);
2635 if (!(val & LCPLL_PLL_ENABLE))
2636 goto out;
2637
2638 val = I915_READ(DPLL_CTRL1);
2639 hw_state->ctrl1 = (val >> (dpll * 6)) & 0x3f;
2640
2641 /* avoid reading back stale values if HDMI mode is not enabled */
2642 if (val & DPLL_CTRL1_HDMI_MODE(dpll)) {
2643 hw_state->cfgcr1 = I915_READ(regs[pll->id].cfgcr1);
2644 hw_state->cfgcr2 = I915_READ(regs[pll->id].cfgcr2);
2645 }
2646 ret = true;
2647
2648out:
2649 intel_display_power_put(dev_priv, POWER_DOMAIN_PLLS);
2650
2651 return ret;
2652}
2653
2654static void skl_shared_dplls_init(struct drm_i915_private *dev_priv)
2655{
2656 int i;
2657
2658 dev_priv->num_shared_dpll = 3;
2659
2660 for (i = 0; i < dev_priv->num_shared_dpll; i++) {
2661 dev_priv->shared_dplls[i].id = i;
2662 dev_priv->shared_dplls[i].name = skl_ddi_pll_names[i];
2663 dev_priv->shared_dplls[i].disable = skl_ddi_pll_disable;
2664 dev_priv->shared_dplls[i].enable = skl_ddi_pll_enable;
2665 dev_priv->shared_dplls[i].get_hw_state =
2666 skl_ddi_pll_get_hw_state;
2667 }
2668}
2669
2670static void broxton_phy_init(struct drm_i915_private *dev_priv,
2671 enum dpio_phy phy)
2672{
2673 enum port port;
2674 uint32_t val;
2675
2676 val = I915_READ(BXT_P_CR_GT_DISP_PWRON);
2677 val |= GT_DISPLAY_POWER_ON(phy);
2678 I915_WRITE(BXT_P_CR_GT_DISP_PWRON, val);
2679
2680 /* Considering 10ms timeout until BSpec is updated */
2681 if (wait_for(I915_READ(BXT_PORT_CL1CM_DW0(phy)) & PHY_POWER_GOOD, 10))
2682 DRM_ERROR("timeout during PHY%d power on\n", phy);
2683
2684 for (port = (phy == DPIO_PHY0 ? PORT_B : PORT_A);
2685 port <= (phy == DPIO_PHY0 ? PORT_C : PORT_A); port++) {
2686 int lane;
2687
2688 for (lane = 0; lane < 4; lane++) {
2689 val = I915_READ(BXT_PORT_TX_DW14_LN(port, lane));
2690 /*
2691 * Note that on CHV this flag is called UPAR, but has
2692 * the same function.
2693 */
2694 val &= ~LATENCY_OPTIM;
2695 if (lane != 1)
2696 val |= LATENCY_OPTIM;
2697
2698 I915_WRITE(BXT_PORT_TX_DW14_LN(port, lane), val);
2699 }
2700 }
2701
2702 /* Program PLL Rcomp code offset */
2703 val = I915_READ(BXT_PORT_CL1CM_DW9(phy));
2704 val &= ~IREF0RC_OFFSET_MASK;
2705 val |= 0xE4 << IREF0RC_OFFSET_SHIFT;
2706 I915_WRITE(BXT_PORT_CL1CM_DW9(phy), val);
2707
2708 val = I915_READ(BXT_PORT_CL1CM_DW10(phy));
2709 val &= ~IREF1RC_OFFSET_MASK;
2710 val |= 0xE4 << IREF1RC_OFFSET_SHIFT;
2711 I915_WRITE(BXT_PORT_CL1CM_DW10(phy), val);
2712
2713 /* Program power gating */
2714 val = I915_READ(BXT_PORT_CL1CM_DW28(phy));
2715 val |= OCL1_POWER_DOWN_EN | DW28_OLDO_DYN_PWR_DOWN_EN |
2716 SUS_CLK_CONFIG;
2717 I915_WRITE(BXT_PORT_CL1CM_DW28(phy), val);
2718
2719 if (phy == DPIO_PHY0) {
2720 val = I915_READ(BXT_PORT_CL2CM_DW6_BC);
2721 val |= DW6_OLDO_DYN_PWR_DOWN_EN;
2722 I915_WRITE(BXT_PORT_CL2CM_DW6_BC, val);
2723 }
2724
2725 val = I915_READ(BXT_PORT_CL1CM_DW30(phy));
2726 val &= ~OCL2_LDOFUSE_PWR_DIS;
2727 /*
2728 * On PHY1 disable power on the second channel, since no port is
2729 * connected there. On PHY0 both channels have a port, so leave it
2730 * enabled.
2731 * TODO: port C is only connected on BXT-P, so on BXT0/1 we should
2732 * power down the second channel on PHY0 as well.
2733 */
2734 if (phy == DPIO_PHY1)
2735 val |= OCL2_LDOFUSE_PWR_DIS;
2736 I915_WRITE(BXT_PORT_CL1CM_DW30(phy), val);
2737
2738 if (phy == DPIO_PHY0) {
2739 uint32_t grc_code;
2740 /*
2741 * PHY0 isn't connected to an RCOMP resistor so copy over
2742 * the corresponding calibrated value from PHY1, and disable
2743 * the automatic calibration on PHY0.
2744 */
2745 if (wait_for(I915_READ(BXT_PORT_REF_DW3(DPIO_PHY1)) & GRC_DONE,
2746 10))
2747 DRM_ERROR("timeout waiting for PHY1 GRC\n");
2748
2749 val = I915_READ(BXT_PORT_REF_DW6(DPIO_PHY1));
2750 val = (val & GRC_CODE_MASK) >> GRC_CODE_SHIFT;
2751 grc_code = val << GRC_CODE_FAST_SHIFT |
2752 val << GRC_CODE_SLOW_SHIFT |
2753 val;
2754 I915_WRITE(BXT_PORT_REF_DW6(DPIO_PHY0), grc_code);
2755
2756 val = I915_READ(BXT_PORT_REF_DW8(DPIO_PHY0));
2757 val |= GRC_DIS | GRC_RDY_OVRD;
2758 I915_WRITE(BXT_PORT_REF_DW8(DPIO_PHY0), val);
2759 }
2760
2761 val = I915_READ(BXT_PHY_CTL_FAMILY(phy));
2762 val |= COMMON_RESET_DIS;
2763 I915_WRITE(BXT_PHY_CTL_FAMILY(phy), val);
2764}
2765
2766void broxton_ddi_phy_init(struct drm_device *dev)
2767{
2768 /* Enable PHY1 first since it provides Rcomp for PHY0 */
2769 broxton_phy_init(dev->dev_private, DPIO_PHY1);
2770 broxton_phy_init(dev->dev_private, DPIO_PHY0);
2771}
2772
2773static void broxton_phy_uninit(struct drm_i915_private *dev_priv,
2774 enum dpio_phy phy)
2775{
2776 uint32_t val;
2777
2778 val = I915_READ(BXT_PHY_CTL_FAMILY(phy));
2779 val &= ~COMMON_RESET_DIS;
2780 I915_WRITE(BXT_PHY_CTL_FAMILY(phy), val);
2781}
2782
2783void broxton_ddi_phy_uninit(struct drm_device *dev)
2784{
2785 struct drm_i915_private *dev_priv = dev->dev_private;
2786
2787 broxton_phy_uninit(dev_priv, DPIO_PHY1);
2788 broxton_phy_uninit(dev_priv, DPIO_PHY0);
2789
2790 /* FIXME: do this in broxton_phy_uninit per phy */
2791 I915_WRITE(BXT_P_CR_GT_DISP_PWRON, 0);
2792}
2793
2794static const char * const bxt_ddi_pll_names[] = {
2795 "PORT PLL A",
2796 "PORT PLL B",
2797 "PORT PLL C",
2798};
2799
2800static void bxt_ddi_pll_enable(struct drm_i915_private *dev_priv,
2801 struct intel_shared_dpll *pll)
2802{
2803 uint32_t temp;
2804 enum port port = (enum port)pll->id; /* 1:1 port->PLL mapping */
2805
2806 temp = I915_READ(BXT_PORT_PLL_ENABLE(port));
2807 temp &= ~PORT_PLL_REF_SEL;
2808 /* Non-SSC reference */
2809 I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp);
2810
2811 /* Disable 10 bit clock */
2812 temp = I915_READ(BXT_PORT_PLL_EBB_4(port));
2813 temp &= ~PORT_PLL_10BIT_CLK_ENABLE;
2814 I915_WRITE(BXT_PORT_PLL_EBB_4(port), temp);
2815
2816 /* Write P1 & P2 */
2817 temp = I915_READ(BXT_PORT_PLL_EBB_0(port));
2818 temp &= ~(PORT_PLL_P1_MASK | PORT_PLL_P2_MASK);
2819 temp |= pll->config.hw_state.ebb0;
2820 I915_WRITE(BXT_PORT_PLL_EBB_0(port), temp);
2821
2822 /* Write M2 integer */
2823 temp = I915_READ(BXT_PORT_PLL(port, 0));
2824 temp &= ~PORT_PLL_M2_MASK;
2825 temp |= pll->config.hw_state.pll0;
2826 I915_WRITE(BXT_PORT_PLL(port, 0), temp);
2827
2828 /* Write N */
2829 temp = I915_READ(BXT_PORT_PLL(port, 1));
2830 temp &= ~PORT_PLL_N_MASK;
2831 temp |= pll->config.hw_state.pll1;
2832 I915_WRITE(BXT_PORT_PLL(port, 1), temp);
2833
2834 /* Write M2 fraction */
2835 temp = I915_READ(BXT_PORT_PLL(port, 2));
2836 temp &= ~PORT_PLL_M2_FRAC_MASK;
2837 temp |= pll->config.hw_state.pll2;
2838 I915_WRITE(BXT_PORT_PLL(port, 2), temp);
2839
2840 /* Write M2 fraction enable */
2841 temp = I915_READ(BXT_PORT_PLL(port, 3));
2842 temp &= ~PORT_PLL_M2_FRAC_ENABLE;
2843 temp |= pll->config.hw_state.pll3;
2844 I915_WRITE(BXT_PORT_PLL(port, 3), temp);
2845
2846 /* Write coeff */
2847 temp = I915_READ(BXT_PORT_PLL(port, 6));
2848 temp &= ~PORT_PLL_PROP_COEFF_MASK;
2849 temp &= ~PORT_PLL_INT_COEFF_MASK;
2850 temp &= ~PORT_PLL_GAIN_CTL_MASK;
2851 temp |= pll->config.hw_state.pll6;
2852 I915_WRITE(BXT_PORT_PLL(port, 6), temp);
2853
2854 /* Write calibration val */
2855 temp = I915_READ(BXT_PORT_PLL(port, 8));
2856 temp &= ~PORT_PLL_TARGET_CNT_MASK;
2857 temp |= pll->config.hw_state.pll8;
2858 I915_WRITE(BXT_PORT_PLL(port, 8), temp);
2859
2860 temp = I915_READ(BXT_PORT_PLL(port, 9));
2861 temp &= ~PORT_PLL_LOCK_THRESHOLD_MASK;
2862 temp |= pll->config.hw_state.pll9;
2863 I915_WRITE(BXT_PORT_PLL(port, 9), temp);
2864
2865 temp = I915_READ(BXT_PORT_PLL(port, 10));
2866 temp &= ~PORT_PLL_DCO_AMP_OVR_EN_H;
2867 temp &= ~PORT_PLL_DCO_AMP_MASK;
2868 temp |= pll->config.hw_state.pll10;
2869 I915_WRITE(BXT_PORT_PLL(port, 10), temp);
2870
2871 /* Recalibrate with new settings */
2872 temp = I915_READ(BXT_PORT_PLL_EBB_4(port));
2873 temp |= PORT_PLL_RECALIBRATE;
2874 I915_WRITE(BXT_PORT_PLL_EBB_4(port), temp);
2875 temp &= ~PORT_PLL_10BIT_CLK_ENABLE;
2876 temp |= pll->config.hw_state.ebb4;
2877 I915_WRITE(BXT_PORT_PLL_EBB_4(port), temp);
2878
2879 /* Enable PLL */
2880 temp = I915_READ(BXT_PORT_PLL_ENABLE(port));
2881 temp |= PORT_PLL_ENABLE;
2882 I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp);
2883 POSTING_READ(BXT_PORT_PLL_ENABLE(port));
2884
2885 if (wait_for_atomic_us((I915_READ(BXT_PORT_PLL_ENABLE(port)) &
2886 PORT_PLL_LOCK), 200))
2887 DRM_ERROR("PLL %d not locked\n", port);
2888
2889 /*
2890 * While we write to the group register to program all lanes at once we
2891 * can read only lane registers and we pick lanes 0/1 for that.
2892 */
2893 temp = I915_READ(BXT_PORT_PCS_DW12_LN01(port));
2894 temp &= ~LANE_STAGGER_MASK;
2895 temp &= ~LANESTAGGER_STRAP_OVRD;
2896 temp |= pll->config.hw_state.pcsdw12;
2897 I915_WRITE(BXT_PORT_PCS_DW12_GRP(port), temp);
2898}
2899
2900static void bxt_ddi_pll_disable(struct drm_i915_private *dev_priv,
2901 struct intel_shared_dpll *pll)
2902{
2903 enum port port = (enum port)pll->id; /* 1:1 port->PLL mapping */
2904 uint32_t temp;
2905
2906 temp = I915_READ(BXT_PORT_PLL_ENABLE(port));
2907 temp &= ~PORT_PLL_ENABLE;
2908 I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp);
2909 POSTING_READ(BXT_PORT_PLL_ENABLE(port));
2910}
2911
2912static bool bxt_ddi_pll_get_hw_state(struct drm_i915_private *dev_priv,
2913 struct intel_shared_dpll *pll,
2914 struct intel_dpll_hw_state *hw_state)
2915{
2916 enum port port = (enum port)pll->id; /* 1:1 port->PLL mapping */
2917 uint32_t val;
2918 bool ret;
2919
2920 if (!intel_display_power_get_if_enabled(dev_priv, POWER_DOMAIN_PLLS))
2921 return false;
2922
2923 ret = false;
2924
2925 val = I915_READ(BXT_PORT_PLL_ENABLE(port));
2926 if (!(val & PORT_PLL_ENABLE))
2927 goto out;
2928
2929 hw_state->ebb0 = I915_READ(BXT_PORT_PLL_EBB_0(port));
2930 hw_state->ebb0 &= PORT_PLL_P1_MASK | PORT_PLL_P2_MASK;
2931
2932 hw_state->ebb4 = I915_READ(BXT_PORT_PLL_EBB_4(port));
2933 hw_state->ebb4 &= PORT_PLL_10BIT_CLK_ENABLE;
2934
2935 hw_state->pll0 = I915_READ(BXT_PORT_PLL(port, 0));
2936 hw_state->pll0 &= PORT_PLL_M2_MASK;
2937
2938 hw_state->pll1 = I915_READ(BXT_PORT_PLL(port, 1));
2939 hw_state->pll1 &= PORT_PLL_N_MASK;
2940
2941 hw_state->pll2 = I915_READ(BXT_PORT_PLL(port, 2));
2942 hw_state->pll2 &= PORT_PLL_M2_FRAC_MASK;
2943
2944 hw_state->pll3 = I915_READ(BXT_PORT_PLL(port, 3));
2945 hw_state->pll3 &= PORT_PLL_M2_FRAC_ENABLE;
2946
2947 hw_state->pll6 = I915_READ(BXT_PORT_PLL(port, 6));
2948 hw_state->pll6 &= PORT_PLL_PROP_COEFF_MASK |
2949 PORT_PLL_INT_COEFF_MASK |
2950 PORT_PLL_GAIN_CTL_MASK;
2951
2952 hw_state->pll8 = I915_READ(BXT_PORT_PLL(port, 8));
2953 hw_state->pll8 &= PORT_PLL_TARGET_CNT_MASK;
2954
2955 hw_state->pll9 = I915_READ(BXT_PORT_PLL(port, 9));
2956 hw_state->pll9 &= PORT_PLL_LOCK_THRESHOLD_MASK;
2957
2958 hw_state->pll10 = I915_READ(BXT_PORT_PLL(port, 10));
2959 hw_state->pll10 &= PORT_PLL_DCO_AMP_OVR_EN_H |
2960 PORT_PLL_DCO_AMP_MASK;
2961
2962 /*
2963 * While we write to the group register to program all lanes at once we
2964 * can read only lane registers. We configure all lanes the same way, so
2965 * here just read out lanes 0/1 and output a note if lanes 2/3 differ.
2966 */
2967 hw_state->pcsdw12 = I915_READ(BXT_PORT_PCS_DW12_LN01(port));
2968 if (I915_READ(BXT_PORT_PCS_DW12_LN23(port)) != hw_state->pcsdw12)
2969 DRM_DEBUG_DRIVER("lane stagger config different for lane 01 (%08x) and 23 (%08x)\n",
2970 hw_state->pcsdw12,
2971 I915_READ(BXT_PORT_PCS_DW12_LN23(port)));
2972 hw_state->pcsdw12 &= LANE_STAGGER_MASK | LANESTAGGER_STRAP_OVRD;
2973
2974 ret = true;
2975
2976out:
2977 intel_display_power_put(dev_priv, POWER_DOMAIN_PLLS);
2978
2979 return ret;
2980}
2981
2982static void bxt_shared_dplls_init(struct drm_i915_private *dev_priv)
2983{
2984 int i;
2985
2986 dev_priv->num_shared_dpll = 3;
2987
2988 for (i = 0; i < dev_priv->num_shared_dpll; i++) {
2989 dev_priv->shared_dplls[i].id = i;
2990 dev_priv->shared_dplls[i].name = bxt_ddi_pll_names[i];
2991 dev_priv->shared_dplls[i].disable = bxt_ddi_pll_disable;
2992 dev_priv->shared_dplls[i].enable = bxt_ddi_pll_enable;
2993 dev_priv->shared_dplls[i].get_hw_state =
2994 bxt_ddi_pll_get_hw_state;
2995 }
2996}
2997
2998void intel_ddi_pll_init(struct drm_device *dev)
2999{
3000 struct drm_i915_private *dev_priv = dev->dev_private;
3001 uint32_t val = I915_READ(LCPLL_CTL);
3002
3003 if (IS_SKYLAKE(dev) || IS_KABYLAKE(dev))
3004 skl_shared_dplls_init(dev_priv);
3005 else if (IS_BROXTON(dev))
3006 bxt_shared_dplls_init(dev_priv);
3007 else
3008 hsw_shared_dplls_init(dev_priv);
3009
3010 if (IS_SKYLAKE(dev) || IS_KABYLAKE(dev)) {
3011 int cdclk_freq;
3012
3013 cdclk_freq = dev_priv->display.get_display_clock_speed(dev);
3014 dev_priv->skl_boot_cdclk = cdclk_freq;
3015 if (skl_sanitize_cdclk(dev_priv))
3016 DRM_DEBUG_KMS("Sanitized cdclk programmed by pre-os\n");
3017 if (!(I915_READ(LCPLL1_CTL) & LCPLL_PLL_ENABLE))
3018 DRM_ERROR("LCPLL1 is disabled\n");
3019 } else if (IS_BROXTON(dev)) {
3020 broxton_init_cdclk(dev);
3021 broxton_ddi_phy_init(dev);
3022 } else {
3023 /*
3024 * The LCPLL register should be turned on by the BIOS. For now
3025 * let's just check its state and print errors in case
3026 * something is wrong. Don't even try to turn it on.
3027 */
3028
3029 if (val & LCPLL_CD_SOURCE_FCLK)
3030 DRM_ERROR("CDCLK source is not LCPLL\n");
3031
3032 if (val & LCPLL_PLL_DISABLE)
3033 DRM_ERROR("LCPLL is disabled\n");
3034 }
3035}
3036
3037void intel_ddi_prepare_link_retrain(struct intel_dp *intel_dp)
3038{
3039 struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
3040 struct drm_i915_private *dev_priv =
3041 to_i915(intel_dig_port->base.base.dev);
3042 enum port port = intel_dig_port->port;
3043 uint32_t val;
3044 bool wait = false;
3045
3046 if (I915_READ(DP_TP_CTL(port)) & DP_TP_CTL_ENABLE) {
3047 val = I915_READ(DDI_BUF_CTL(port));
3048 if (val & DDI_BUF_CTL_ENABLE) {
3049 val &= ~DDI_BUF_CTL_ENABLE;
3050 I915_WRITE(DDI_BUF_CTL(port), val);
3051 wait = true;
3052 }
3053
3054 val = I915_READ(DP_TP_CTL(port));
3055 val &= ~(DP_TP_CTL_ENABLE | DP_TP_CTL_LINK_TRAIN_MASK);
3056 val |= DP_TP_CTL_LINK_TRAIN_PAT1;
3057 I915_WRITE(DP_TP_CTL(port), val);
3058 POSTING_READ(DP_TP_CTL(port));
3059
3060 if (wait)
3061 intel_wait_ddi_buf_idle(dev_priv, port);
3062 }
3063
3064 val = DP_TP_CTL_ENABLE |
3065 DP_TP_CTL_LINK_TRAIN_PAT1 | DP_TP_CTL_SCRAMBLE_DISABLE;
3066 if (intel_dp->is_mst)
3067 val |= DP_TP_CTL_MODE_MST;
3068 else {
3069 val |= DP_TP_CTL_MODE_SST;
3070 if (drm_dp_enhanced_frame_cap(intel_dp->dpcd))
3071 val |= DP_TP_CTL_ENHANCED_FRAME_ENABLE;
3072 }
3073 I915_WRITE(DP_TP_CTL(port), val);
3074 POSTING_READ(DP_TP_CTL(port));
3075
3076 intel_dp->DP |= DDI_BUF_CTL_ENABLE;
3077 I915_WRITE(DDI_BUF_CTL(port), intel_dp->DP);
3078 POSTING_READ(DDI_BUF_CTL(port));
3079
3080 udelay(600);
3081}
3082
3083void intel_ddi_fdi_disable(struct drm_crtc *crtc)
3084{
3085 struct drm_i915_private *dev_priv = crtc->dev->dev_private;
3086 struct intel_encoder *intel_encoder = intel_ddi_get_crtc_encoder(crtc);
3087 uint32_t val;
3088
3089 intel_ddi_post_disable(intel_encoder);
3090
3091 val = I915_READ(FDI_RX_CTL(PIPE_A));
3092 val &= ~FDI_RX_ENABLE;
3093 I915_WRITE(FDI_RX_CTL(PIPE_A), val);
3094
3095 val = I915_READ(FDI_RX_MISC(PIPE_A));
3096 val &= ~(FDI_RX_PWRDN_LANE1_MASK | FDI_RX_PWRDN_LANE0_MASK);
3097 val |= FDI_RX_PWRDN_LANE1_VAL(2) | FDI_RX_PWRDN_LANE0_VAL(2);
3098 I915_WRITE(FDI_RX_MISC(PIPE_A), val);
3099
3100 val = I915_READ(FDI_RX_CTL(PIPE_A));
3101 val &= ~FDI_PCDCLK;
3102 I915_WRITE(FDI_RX_CTL(PIPE_A), val);
3103
3104 val = I915_READ(FDI_RX_CTL(PIPE_A));
3105 val &= ~FDI_RX_PLL_ENABLE;
3106 I915_WRITE(FDI_RX_CTL(PIPE_A), val);
3107}
3108
3109void intel_ddi_get_config(struct intel_encoder *encoder,
3110 struct intel_crtc_state *pipe_config)
3111{
3112 struct drm_i915_private *dev_priv = encoder->base.dev->dev_private;
3113 struct intel_crtc *intel_crtc = to_intel_crtc(encoder->base.crtc);
3114 enum transcoder cpu_transcoder = pipe_config->cpu_transcoder;
3115 struct intel_hdmi *intel_hdmi;
3116 u32 temp, flags = 0;
3117
3118 temp = I915_READ(TRANS_DDI_FUNC_CTL(cpu_transcoder));
3119 if (temp & TRANS_DDI_PHSYNC)
3120 flags |= DRM_MODE_FLAG_PHSYNC;
3121 else
3122 flags |= DRM_MODE_FLAG_NHSYNC;
3123 if (temp & TRANS_DDI_PVSYNC)
3124 flags |= DRM_MODE_FLAG_PVSYNC;
3125 else
3126 flags |= DRM_MODE_FLAG_NVSYNC;
3127
3128 pipe_config->base.adjusted_mode.flags |= flags;
3129
3130 switch (temp & TRANS_DDI_BPC_MASK) {
3131 case TRANS_DDI_BPC_6:
3132 pipe_config->pipe_bpp = 18;
3133 break;
3134 case TRANS_DDI_BPC_8:
3135 pipe_config->pipe_bpp = 24;
3136 break;
3137 case TRANS_DDI_BPC_10:
3138 pipe_config->pipe_bpp = 30;
3139 break;
3140 case TRANS_DDI_BPC_12:
3141 pipe_config->pipe_bpp = 36;
3142 break;
3143 default:
3144 break;
3145 }
3146
3147 switch (temp & TRANS_DDI_MODE_SELECT_MASK) {
3148 case TRANS_DDI_MODE_SELECT_HDMI:
3149 pipe_config->has_hdmi_sink = true;
3150 intel_hdmi = enc_to_intel_hdmi(&encoder->base);
3151
3152 if (intel_hdmi->infoframe_enabled(&encoder->base, pipe_config))
3153 pipe_config->has_infoframe = true;
3154 break;
3155 case TRANS_DDI_MODE_SELECT_DVI:
3156 case TRANS_DDI_MODE_SELECT_FDI:
3157 break;
3158 case TRANS_DDI_MODE_SELECT_DP_SST:
3159 case TRANS_DDI_MODE_SELECT_DP_MST:
3160 pipe_config->has_dp_encoder = true;
3161 pipe_config->lane_count =
3162 ((temp & DDI_PORT_WIDTH_MASK) >> DDI_PORT_WIDTH_SHIFT) + 1;
3163 intel_dp_get_m_n(intel_crtc, pipe_config);
3164 break;
3165 default:
3166 break;
3167 }
3168
3169 if (intel_display_power_is_enabled(dev_priv, POWER_DOMAIN_AUDIO)) {
3170 temp = I915_READ(HSW_AUD_PIN_ELD_CP_VLD);
3171 if (temp & AUDIO_OUTPUT_ENABLE(intel_crtc->pipe))
3172 pipe_config->has_audio = true;
3173 }
3174
3175 if (encoder->type == INTEL_OUTPUT_EDP && dev_priv->vbt.edp_bpp &&
3176 pipe_config->pipe_bpp > dev_priv->vbt.edp_bpp) {
3177 /*
3178 * This is a big fat ugly hack.
3179 *
3180 * Some machines in UEFI boot mode provide us a VBT that has 18
3181 * bpp and 1.62 GHz link bandwidth for eDP, which for reasons
3182 * unknown we fail to light up. Yet the same BIOS boots up with
3183 * 24 bpp and 2.7 GHz link. Use the same bpp as the BIOS uses as
3184 * max, not what it tells us to use.
3185 *
3186 * Note: This will still be broken if the eDP panel is not lit
3187 * up by the BIOS, and thus we can't get the mode at module
3188 * load.
3189 */
3190 DRM_DEBUG_KMS("pipe has %d bpp for eDP panel, overriding BIOS-provided max %d bpp\n",
3191 pipe_config->pipe_bpp, dev_priv->vbt.edp_bpp);
3192 dev_priv->vbt.edp_bpp = pipe_config->pipe_bpp;
3193 }
3194
3195 intel_ddi_clock_get(encoder, pipe_config);
3196}
3197
3198static bool intel_ddi_compute_config(struct intel_encoder *encoder,
3199 struct intel_crtc_state *pipe_config)
3200{
3201 int type = encoder->type;
3202 int port = intel_ddi_get_encoder_port(encoder);
3203
3204 WARN(type == INTEL_OUTPUT_UNKNOWN, "compute_config() on unknown output!\n");
3205
3206 if (port == PORT_A)
3207 pipe_config->cpu_transcoder = TRANSCODER_EDP;
3208
3209 if (type == INTEL_OUTPUT_HDMI)
3210 return intel_hdmi_compute_config(encoder, pipe_config);
3211 else
3212 return intel_dp_compute_config(encoder, pipe_config);
3213}
3214
3215static const struct drm_encoder_funcs intel_ddi_funcs = {
3216 .reset = intel_dp_encoder_reset,
3217 .destroy = intel_dp_encoder_destroy,
3218};
3219
3220static struct intel_connector *
3221intel_ddi_init_dp_connector(struct intel_digital_port *intel_dig_port)
3222{
3223 struct intel_connector *connector;
3224 enum port port = intel_dig_port->port;
3225
3226 connector = intel_connector_alloc();
3227 if (!connector)
3228 return NULL;
3229
3230 intel_dig_port->dp.output_reg = DDI_BUF_CTL(port);
3231 if (!intel_dp_init_connector(intel_dig_port, connector)) {
3232 kfree(connector);
3233 return NULL;
3234 }
3235
3236 return connector;
3237}
3238
3239static struct intel_connector *
3240intel_ddi_init_hdmi_connector(struct intel_digital_port *intel_dig_port)
3241{
3242 struct intel_connector *connector;
3243 enum port port = intel_dig_port->port;
3244
3245 connector = intel_connector_alloc();
3246 if (!connector)
3247 return NULL;
3248
3249 intel_dig_port->hdmi.hdmi_reg = DDI_BUF_CTL(port);
3250 intel_hdmi_init_connector(intel_dig_port, connector);
3251
3252 return connector;
3253}
3254
3255void intel_ddi_init(struct drm_device *dev, enum port port)
3256{
3257 struct drm_i915_private *dev_priv = dev->dev_private;
3258 struct intel_digital_port *intel_dig_port;
3259 struct intel_encoder *intel_encoder;
3260 struct drm_encoder *encoder;
3261 bool init_hdmi, init_dp;
3262 int max_lanes;
3263
3264 if (I915_READ(DDI_BUF_CTL(PORT_A)) & DDI_A_4_LANES) {
3265 switch (port) {
3266 case PORT_A:
3267 max_lanes = 4;
3268 break;
3269 case PORT_E:
3270 max_lanes = 0;
3271 break;
3272 default:
3273 max_lanes = 4;
3274 break;
3275 }
3276 } else {
3277 switch (port) {
3278 case PORT_A:
3279 max_lanes = 2;
3280 break;
3281 case PORT_E:
3282 max_lanes = 2;
3283 break;
3284 default:
3285 max_lanes = 4;
3286 break;
3287 }
3288 }
3289
3290 init_hdmi = (dev_priv->vbt.ddi_port_info[port].supports_dvi ||
3291 dev_priv->vbt.ddi_port_info[port].supports_hdmi);
3292 init_dp = dev_priv->vbt.ddi_port_info[port].supports_dp;
3293 if (!init_dp && !init_hdmi) {
3294 DRM_DEBUG_KMS("VBT says port %c is not DVI/HDMI/DP compatible, respect it\n",
3295 port_name(port));
3296 return;
3297 }
3298
3299 intel_dig_port = kzalloc(sizeof(*intel_dig_port), GFP_KERNEL);
3300 if (!intel_dig_port)
3301 return;
3302
3303 intel_encoder = &intel_dig_port->base;
3304 encoder = &intel_encoder->base;
3305
3306 drm_encoder_init(dev, encoder, &intel_ddi_funcs,
3307 DRM_MODE_ENCODER_TMDS, NULL);
3308
3309 intel_encoder->compute_config = intel_ddi_compute_config;
3310 intel_encoder->enable = intel_enable_ddi;
3311 intel_encoder->pre_enable = intel_ddi_pre_enable;
3312 intel_encoder->disable = intel_disable_ddi;
3313 intel_encoder->post_disable = intel_ddi_post_disable;
3314 intel_encoder->get_hw_state = intel_ddi_get_hw_state;
3315 intel_encoder->get_config = intel_ddi_get_config;
3316 intel_encoder->suspend = intel_dp_encoder_suspend;
3317
3318 intel_dig_port->port = port;
3319 intel_dig_port->saved_port_bits = I915_READ(DDI_BUF_CTL(port)) &
3320 (DDI_BUF_PORT_REVERSAL |
3321 DDI_A_4_LANES);
3322
3323 /*
3324 * Bspec says that DDI_A_4_LANES is the only supported configuration
3325 * for Broxton. Yet some BIOS fail to set this bit on port A if eDP
3326 * wasn't lit up at boot. Force this bit on in our internal
3327 * configuration so that we use the proper lane count for our
3328 * calculations.
3329 */
3330 if (IS_BROXTON(dev) && port == PORT_A) {
3331 if (!(intel_dig_port->saved_port_bits & DDI_A_4_LANES)) {
3332 DRM_DEBUG_KMS("BXT BIOS forgot to set DDI_A_4_LANES for port A; fixing\n");
3333 intel_dig_port->saved_port_bits |= DDI_A_4_LANES;
3334 max_lanes = 4;
3335 }
3336 }
3337
3338 intel_dig_port->max_lanes = max_lanes;
3339
3340 intel_encoder->type = INTEL_OUTPUT_UNKNOWN;
3341 intel_encoder->crtc_mask = (1 << 0) | (1 << 1) | (1 << 2);
3342 intel_encoder->cloneable = 0;
3343
3344 if (init_dp) {
3345 if (!intel_ddi_init_dp_connector(intel_dig_port))
3346 goto err;
3347
3348 intel_dig_port->hpd_pulse = intel_dp_hpd_pulse;
3349 /*
3350 * On BXT A0/A1, sw needs to activate DDIA HPD logic and
3351 * interrupts to check the external panel connection.
3352 */
3353 if (IS_BXT_REVID(dev, 0, BXT_REVID_A1) && port == PORT_B)
3354 dev_priv->hotplug.irq_port[PORT_A] = intel_dig_port;
3355 else
3356 dev_priv->hotplug.irq_port[port] = intel_dig_port;
3357 }
3358
3359 /* In theory we don't need the encoder->type check, but leave it just in
3360 * case we have some really bad VBTs... */
3361 if (intel_encoder->type != INTEL_OUTPUT_EDP && init_hdmi) {
3362 if (!intel_ddi_init_hdmi_connector(intel_dig_port))
3363 goto err;
3364 }
3365
3366 return;
3367
3368err:
3369 drm_encoder_cleanup(encoder);
3370 kfree(intel_dig_port);
3371}
1/*
2 * Copyright © 2012 Intel Corporation
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 (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
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
21 * IN THE SOFTWARE.
22 *
23 * Authors:
24 * Eugeni Dodonov <eugeni.dodonov@intel.com>
25 *
26 */
27
28#include <drm/drm_scdc_helper.h>
29#include "i915_drv.h"
30#include "intel_drv.h"
31
32struct ddi_buf_trans {
33 u32 trans1; /* balance leg enable, de-emph level */
34 u32 trans2; /* vref sel, vswing */
35 u8 i_boost; /* SKL: I_boost; valid: 0x0, 0x1, 0x3, 0x7 */
36};
37
38static const u8 index_to_dp_signal_levels[] = {
39 [0] = DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_0,
40 [1] = DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_1,
41 [2] = DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_2,
42 [3] = DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_3,
43 [4] = DP_TRAIN_VOLTAGE_SWING_LEVEL_1 | DP_TRAIN_PRE_EMPH_LEVEL_0,
44 [5] = DP_TRAIN_VOLTAGE_SWING_LEVEL_1 | DP_TRAIN_PRE_EMPH_LEVEL_1,
45 [6] = DP_TRAIN_VOLTAGE_SWING_LEVEL_1 | DP_TRAIN_PRE_EMPH_LEVEL_2,
46 [7] = DP_TRAIN_VOLTAGE_SWING_LEVEL_2 | DP_TRAIN_PRE_EMPH_LEVEL_0,
47 [8] = DP_TRAIN_VOLTAGE_SWING_LEVEL_2 | DP_TRAIN_PRE_EMPH_LEVEL_1,
48 [9] = DP_TRAIN_VOLTAGE_SWING_LEVEL_3 | DP_TRAIN_PRE_EMPH_LEVEL_0,
49};
50
51/* HDMI/DVI modes ignore everything but the last 2 items. So we share
52 * them for both DP and FDI transports, allowing those ports to
53 * automatically adapt to HDMI connections as well
54 */
55static const struct ddi_buf_trans hsw_ddi_translations_dp[] = {
56 { 0x00FFFFFF, 0x0006000E, 0x0 },
57 { 0x00D75FFF, 0x0005000A, 0x0 },
58 { 0x00C30FFF, 0x00040006, 0x0 },
59 { 0x80AAAFFF, 0x000B0000, 0x0 },
60 { 0x00FFFFFF, 0x0005000A, 0x0 },
61 { 0x00D75FFF, 0x000C0004, 0x0 },
62 { 0x80C30FFF, 0x000B0000, 0x0 },
63 { 0x00FFFFFF, 0x00040006, 0x0 },
64 { 0x80D75FFF, 0x000B0000, 0x0 },
65};
66
67static const struct ddi_buf_trans hsw_ddi_translations_fdi[] = {
68 { 0x00FFFFFF, 0x0007000E, 0x0 },
69 { 0x00D75FFF, 0x000F000A, 0x0 },
70 { 0x00C30FFF, 0x00060006, 0x0 },
71 { 0x00AAAFFF, 0x001E0000, 0x0 },
72 { 0x00FFFFFF, 0x000F000A, 0x0 },
73 { 0x00D75FFF, 0x00160004, 0x0 },
74 { 0x00C30FFF, 0x001E0000, 0x0 },
75 { 0x00FFFFFF, 0x00060006, 0x0 },
76 { 0x00D75FFF, 0x001E0000, 0x0 },
77};
78
79static const struct ddi_buf_trans hsw_ddi_translations_hdmi[] = {
80 /* Idx NT mV d T mV d db */
81 { 0x00FFFFFF, 0x0006000E, 0x0 },/* 0: 400 400 0 */
82 { 0x00E79FFF, 0x000E000C, 0x0 },/* 1: 400 500 2 */
83 { 0x00D75FFF, 0x0005000A, 0x0 },/* 2: 400 600 3.5 */
84 { 0x00FFFFFF, 0x0005000A, 0x0 },/* 3: 600 600 0 */
85 { 0x00E79FFF, 0x001D0007, 0x0 },/* 4: 600 750 2 */
86 { 0x00D75FFF, 0x000C0004, 0x0 },/* 5: 600 900 3.5 */
87 { 0x00FFFFFF, 0x00040006, 0x0 },/* 6: 800 800 0 */
88 { 0x80E79FFF, 0x00030002, 0x0 },/* 7: 800 1000 2 */
89 { 0x00FFFFFF, 0x00140005, 0x0 },/* 8: 850 850 0 */
90 { 0x00FFFFFF, 0x000C0004, 0x0 },/* 9: 900 900 0 */
91 { 0x00FFFFFF, 0x001C0003, 0x0 },/* 10: 950 950 0 */
92 { 0x80FFFFFF, 0x00030002, 0x0 },/* 11: 1000 1000 0 */
93};
94
95static const struct ddi_buf_trans bdw_ddi_translations_edp[] = {
96 { 0x00FFFFFF, 0x00000012, 0x0 },
97 { 0x00EBAFFF, 0x00020011, 0x0 },
98 { 0x00C71FFF, 0x0006000F, 0x0 },
99 { 0x00AAAFFF, 0x000E000A, 0x0 },
100 { 0x00FFFFFF, 0x00020011, 0x0 },
101 { 0x00DB6FFF, 0x0005000F, 0x0 },
102 { 0x00BEEFFF, 0x000A000C, 0x0 },
103 { 0x00FFFFFF, 0x0005000F, 0x0 },
104 { 0x00DB6FFF, 0x000A000C, 0x0 },
105};
106
107static const struct ddi_buf_trans bdw_ddi_translations_dp[] = {
108 { 0x00FFFFFF, 0x0007000E, 0x0 },
109 { 0x00D75FFF, 0x000E000A, 0x0 },
110 { 0x00BEFFFF, 0x00140006, 0x0 },
111 { 0x80B2CFFF, 0x001B0002, 0x0 },
112 { 0x00FFFFFF, 0x000E000A, 0x0 },
113 { 0x00DB6FFF, 0x00160005, 0x0 },
114 { 0x80C71FFF, 0x001A0002, 0x0 },
115 { 0x00F7DFFF, 0x00180004, 0x0 },
116 { 0x80D75FFF, 0x001B0002, 0x0 },
117};
118
119static const struct ddi_buf_trans bdw_ddi_translations_fdi[] = {
120 { 0x00FFFFFF, 0x0001000E, 0x0 },
121 { 0x00D75FFF, 0x0004000A, 0x0 },
122 { 0x00C30FFF, 0x00070006, 0x0 },
123 { 0x00AAAFFF, 0x000C0000, 0x0 },
124 { 0x00FFFFFF, 0x0004000A, 0x0 },
125 { 0x00D75FFF, 0x00090004, 0x0 },
126 { 0x00C30FFF, 0x000C0000, 0x0 },
127 { 0x00FFFFFF, 0x00070006, 0x0 },
128 { 0x00D75FFF, 0x000C0000, 0x0 },
129};
130
131static const struct ddi_buf_trans bdw_ddi_translations_hdmi[] = {
132 /* Idx NT mV d T mV df db */
133 { 0x00FFFFFF, 0x0007000E, 0x0 },/* 0: 400 400 0 */
134 { 0x00D75FFF, 0x000E000A, 0x0 },/* 1: 400 600 3.5 */
135 { 0x00BEFFFF, 0x00140006, 0x0 },/* 2: 400 800 6 */
136 { 0x00FFFFFF, 0x0009000D, 0x0 },/* 3: 450 450 0 */
137 { 0x00FFFFFF, 0x000E000A, 0x0 },/* 4: 600 600 0 */
138 { 0x00D7FFFF, 0x00140006, 0x0 },/* 5: 600 800 2.5 */
139 { 0x80CB2FFF, 0x001B0002, 0x0 },/* 6: 600 1000 4.5 */
140 { 0x00FFFFFF, 0x00140006, 0x0 },/* 7: 800 800 0 */
141 { 0x80E79FFF, 0x001B0002, 0x0 },/* 8: 800 1000 2 */
142 { 0x80FFFFFF, 0x001B0002, 0x0 },/* 9: 1000 1000 0 */
143};
144
145/* Skylake H and S */
146static const struct ddi_buf_trans skl_ddi_translations_dp[] = {
147 { 0x00002016, 0x000000A0, 0x0 },
148 { 0x00005012, 0x0000009B, 0x0 },
149 { 0x00007011, 0x00000088, 0x0 },
150 { 0x80009010, 0x000000C0, 0x1 },
151 { 0x00002016, 0x0000009B, 0x0 },
152 { 0x00005012, 0x00000088, 0x0 },
153 { 0x80007011, 0x000000C0, 0x1 },
154 { 0x00002016, 0x000000DF, 0x0 },
155 { 0x80005012, 0x000000C0, 0x1 },
156};
157
158/* Skylake U */
159static const struct ddi_buf_trans skl_u_ddi_translations_dp[] = {
160 { 0x0000201B, 0x000000A2, 0x0 },
161 { 0x00005012, 0x00000088, 0x0 },
162 { 0x80007011, 0x000000CD, 0x1 },
163 { 0x80009010, 0x000000C0, 0x1 },
164 { 0x0000201B, 0x0000009D, 0x0 },
165 { 0x80005012, 0x000000C0, 0x1 },
166 { 0x80007011, 0x000000C0, 0x1 },
167 { 0x00002016, 0x00000088, 0x0 },
168 { 0x80005012, 0x000000C0, 0x1 },
169};
170
171/* Skylake Y */
172static const struct ddi_buf_trans skl_y_ddi_translations_dp[] = {
173 { 0x00000018, 0x000000A2, 0x0 },
174 { 0x00005012, 0x00000088, 0x0 },
175 { 0x80007011, 0x000000CD, 0x3 },
176 { 0x80009010, 0x000000C0, 0x3 },
177 { 0x00000018, 0x0000009D, 0x0 },
178 { 0x80005012, 0x000000C0, 0x3 },
179 { 0x80007011, 0x000000C0, 0x3 },
180 { 0x00000018, 0x00000088, 0x0 },
181 { 0x80005012, 0x000000C0, 0x3 },
182};
183
184/* Kabylake H and S */
185static const struct ddi_buf_trans kbl_ddi_translations_dp[] = {
186 { 0x00002016, 0x000000A0, 0x0 },
187 { 0x00005012, 0x0000009B, 0x0 },
188 { 0x00007011, 0x00000088, 0x0 },
189 { 0x80009010, 0x000000C0, 0x1 },
190 { 0x00002016, 0x0000009B, 0x0 },
191 { 0x00005012, 0x00000088, 0x0 },
192 { 0x80007011, 0x000000C0, 0x1 },
193 { 0x00002016, 0x00000097, 0x0 },
194 { 0x80005012, 0x000000C0, 0x1 },
195};
196
197/* Kabylake U */
198static const struct ddi_buf_trans kbl_u_ddi_translations_dp[] = {
199 { 0x0000201B, 0x000000A1, 0x0 },
200 { 0x00005012, 0x00000088, 0x0 },
201 { 0x80007011, 0x000000CD, 0x3 },
202 { 0x80009010, 0x000000C0, 0x3 },
203 { 0x0000201B, 0x0000009D, 0x0 },
204 { 0x80005012, 0x000000C0, 0x3 },
205 { 0x80007011, 0x000000C0, 0x3 },
206 { 0x00002016, 0x0000004F, 0x0 },
207 { 0x80005012, 0x000000C0, 0x3 },
208};
209
210/* Kabylake Y */
211static const struct ddi_buf_trans kbl_y_ddi_translations_dp[] = {
212 { 0x00001017, 0x000000A1, 0x0 },
213 { 0x00005012, 0x00000088, 0x0 },
214 { 0x80007011, 0x000000CD, 0x3 },
215 { 0x8000800F, 0x000000C0, 0x3 },
216 { 0x00001017, 0x0000009D, 0x0 },
217 { 0x80005012, 0x000000C0, 0x3 },
218 { 0x80007011, 0x000000C0, 0x3 },
219 { 0x00001017, 0x0000004C, 0x0 },
220 { 0x80005012, 0x000000C0, 0x3 },
221};
222
223/*
224 * Skylake/Kabylake H and S
225 * eDP 1.4 low vswing translation parameters
226 */
227static const struct ddi_buf_trans skl_ddi_translations_edp[] = {
228 { 0x00000018, 0x000000A8, 0x0 },
229 { 0x00004013, 0x000000A9, 0x0 },
230 { 0x00007011, 0x000000A2, 0x0 },
231 { 0x00009010, 0x0000009C, 0x0 },
232 { 0x00000018, 0x000000A9, 0x0 },
233 { 0x00006013, 0x000000A2, 0x0 },
234 { 0x00007011, 0x000000A6, 0x0 },
235 { 0x00000018, 0x000000AB, 0x0 },
236 { 0x00007013, 0x0000009F, 0x0 },
237 { 0x00000018, 0x000000DF, 0x0 },
238};
239
240/*
241 * Skylake/Kabylake U
242 * eDP 1.4 low vswing translation parameters
243 */
244static const struct ddi_buf_trans skl_u_ddi_translations_edp[] = {
245 { 0x00000018, 0x000000A8, 0x0 },
246 { 0x00004013, 0x000000A9, 0x0 },
247 { 0x00007011, 0x000000A2, 0x0 },
248 { 0x00009010, 0x0000009C, 0x0 },
249 { 0x00000018, 0x000000A9, 0x0 },
250 { 0x00006013, 0x000000A2, 0x0 },
251 { 0x00007011, 0x000000A6, 0x0 },
252 { 0x00002016, 0x000000AB, 0x0 },
253 { 0x00005013, 0x0000009F, 0x0 },
254 { 0x00000018, 0x000000DF, 0x0 },
255};
256
257/*
258 * Skylake/Kabylake Y
259 * eDP 1.4 low vswing translation parameters
260 */
261static const struct ddi_buf_trans skl_y_ddi_translations_edp[] = {
262 { 0x00000018, 0x000000A8, 0x0 },
263 { 0x00004013, 0x000000AB, 0x0 },
264 { 0x00007011, 0x000000A4, 0x0 },
265 { 0x00009010, 0x000000DF, 0x0 },
266 { 0x00000018, 0x000000AA, 0x0 },
267 { 0x00006013, 0x000000A4, 0x0 },
268 { 0x00007011, 0x0000009D, 0x0 },
269 { 0x00000018, 0x000000A0, 0x0 },
270 { 0x00006012, 0x000000DF, 0x0 },
271 { 0x00000018, 0x0000008A, 0x0 },
272};
273
274/* Skylake/Kabylake U, H and S */
275static const struct ddi_buf_trans skl_ddi_translations_hdmi[] = {
276 { 0x00000018, 0x000000AC, 0x0 },
277 { 0x00005012, 0x0000009D, 0x0 },
278 { 0x00007011, 0x00000088, 0x0 },
279 { 0x00000018, 0x000000A1, 0x0 },
280 { 0x00000018, 0x00000098, 0x0 },
281 { 0x00004013, 0x00000088, 0x0 },
282 { 0x80006012, 0x000000CD, 0x1 },
283 { 0x00000018, 0x000000DF, 0x0 },
284 { 0x80003015, 0x000000CD, 0x1 }, /* Default */
285 { 0x80003015, 0x000000C0, 0x1 },
286 { 0x80000018, 0x000000C0, 0x1 },
287};
288
289/* Skylake/Kabylake Y */
290static const struct ddi_buf_trans skl_y_ddi_translations_hdmi[] = {
291 { 0x00000018, 0x000000A1, 0x0 },
292 { 0x00005012, 0x000000DF, 0x0 },
293 { 0x80007011, 0x000000CB, 0x3 },
294 { 0x00000018, 0x000000A4, 0x0 },
295 { 0x00000018, 0x0000009D, 0x0 },
296 { 0x00004013, 0x00000080, 0x0 },
297 { 0x80006013, 0x000000C0, 0x3 },
298 { 0x00000018, 0x0000008A, 0x0 },
299 { 0x80003015, 0x000000C0, 0x3 }, /* Default */
300 { 0x80003015, 0x000000C0, 0x3 },
301 { 0x80000018, 0x000000C0, 0x3 },
302};
303
304struct bxt_ddi_buf_trans {
305 u8 margin; /* swing value */
306 u8 scale; /* scale value */
307 u8 enable; /* scale enable */
308 u8 deemphasis;
309};
310
311static const struct bxt_ddi_buf_trans bxt_ddi_translations_dp[] = {
312 /* Idx NT mV diff db */
313 { 52, 0x9A, 0, 128, }, /* 0: 400 0 */
314 { 78, 0x9A, 0, 85, }, /* 1: 400 3.5 */
315 { 104, 0x9A, 0, 64, }, /* 2: 400 6 */
316 { 154, 0x9A, 0, 43, }, /* 3: 400 9.5 */
317 { 77, 0x9A, 0, 128, }, /* 4: 600 0 */
318 { 116, 0x9A, 0, 85, }, /* 5: 600 3.5 */
319 { 154, 0x9A, 0, 64, }, /* 6: 600 6 */
320 { 102, 0x9A, 0, 128, }, /* 7: 800 0 */
321 { 154, 0x9A, 0, 85, }, /* 8: 800 3.5 */
322 { 154, 0x9A, 1, 128, }, /* 9: 1200 0 */
323};
324
325static const struct bxt_ddi_buf_trans bxt_ddi_translations_edp[] = {
326 /* Idx NT mV diff db */
327 { 26, 0, 0, 128, }, /* 0: 200 0 */
328 { 38, 0, 0, 112, }, /* 1: 200 1.5 */
329 { 48, 0, 0, 96, }, /* 2: 200 4 */
330 { 54, 0, 0, 69, }, /* 3: 200 6 */
331 { 32, 0, 0, 128, }, /* 4: 250 0 */
332 { 48, 0, 0, 104, }, /* 5: 250 1.5 */
333 { 54, 0, 0, 85, }, /* 6: 250 4 */
334 { 43, 0, 0, 128, }, /* 7: 300 0 */
335 { 54, 0, 0, 101, }, /* 8: 300 1.5 */
336 { 48, 0, 0, 128, }, /* 9: 300 0 */
337};
338
339/* BSpec has 2 recommended values - entries 0 and 8.
340 * Using the entry with higher vswing.
341 */
342static const struct bxt_ddi_buf_trans bxt_ddi_translations_hdmi[] = {
343 /* Idx NT mV diff db */
344 { 52, 0x9A, 0, 128, }, /* 0: 400 0 */
345 { 52, 0x9A, 0, 85, }, /* 1: 400 3.5 */
346 { 52, 0x9A, 0, 64, }, /* 2: 400 6 */
347 { 42, 0x9A, 0, 43, }, /* 3: 400 9.5 */
348 { 77, 0x9A, 0, 128, }, /* 4: 600 0 */
349 { 77, 0x9A, 0, 85, }, /* 5: 600 3.5 */
350 { 77, 0x9A, 0, 64, }, /* 6: 600 6 */
351 { 102, 0x9A, 0, 128, }, /* 7: 800 0 */
352 { 102, 0x9A, 0, 85, }, /* 8: 800 3.5 */
353 { 154, 0x9A, 1, 128, }, /* 9: 1200 0 */
354};
355
356struct cnl_ddi_buf_trans {
357 u8 dw2_swing_sel;
358 u8 dw7_n_scalar;
359 u8 dw4_cursor_coeff;
360 u8 dw4_post_cursor_2;
361 u8 dw4_post_cursor_1;
362};
363
364/* Voltage Swing Programming for VccIO 0.85V for DP */
365static const struct cnl_ddi_buf_trans cnl_ddi_translations_dp_0_85V[] = {
366 /* NT mV Trans mV db */
367 { 0xA, 0x5D, 0x3F, 0x00, 0x00 }, /* 350 350 0.0 */
368 { 0xA, 0x6A, 0x38, 0x00, 0x07 }, /* 350 500 3.1 */
369 { 0xB, 0x7A, 0x32, 0x00, 0x0D }, /* 350 700 6.0 */
370 { 0x6, 0x7C, 0x2D, 0x00, 0x12 }, /* 350 900 8.2 */
371 { 0xA, 0x69, 0x3F, 0x00, 0x00 }, /* 500 500 0.0 */
372 { 0xB, 0x7A, 0x36, 0x00, 0x09 }, /* 500 700 2.9 */
373 { 0x6, 0x7C, 0x30, 0x00, 0x0F }, /* 500 900 5.1 */
374 { 0xB, 0x7D, 0x3C, 0x00, 0x03 }, /* 650 725 0.9 */
375 { 0x6, 0x7C, 0x34, 0x00, 0x0B }, /* 600 900 3.5 */
376 { 0x6, 0x7B, 0x3F, 0x00, 0x00 }, /* 900 900 0.0 */
377};
378
379/* Voltage Swing Programming for VccIO 0.85V for HDMI */
380static const struct cnl_ddi_buf_trans cnl_ddi_translations_hdmi_0_85V[] = {
381 /* NT mV Trans mV db */
382 { 0xA, 0x60, 0x3F, 0x00, 0x00 }, /* 450 450 0.0 */
383 { 0xB, 0x73, 0x36, 0x00, 0x09 }, /* 450 650 3.2 */
384 { 0x6, 0x7F, 0x31, 0x00, 0x0E }, /* 450 850 5.5 */
385 { 0xB, 0x73, 0x3F, 0x00, 0x00 }, /* 650 650 0.0 */
386 { 0x6, 0x7F, 0x37, 0x00, 0x08 }, /* 650 850 2.3 */
387 { 0x6, 0x7F, 0x3F, 0x00, 0x00 }, /* 850 850 0.0 */
388 { 0x6, 0x7F, 0x35, 0x00, 0x0A }, /* 600 850 3.0 */
389};
390
391/* Voltage Swing Programming for VccIO 0.85V for eDP */
392static const struct cnl_ddi_buf_trans cnl_ddi_translations_edp_0_85V[] = {
393 /* NT mV Trans mV db */
394 { 0xA, 0x66, 0x3A, 0x00, 0x05 }, /* 384 500 2.3 */
395 { 0x0, 0x7F, 0x38, 0x00, 0x07 }, /* 153 200 2.3 */
396 { 0x8, 0x7F, 0x38, 0x00, 0x07 }, /* 192 250 2.3 */
397 { 0x1, 0x7F, 0x38, 0x00, 0x07 }, /* 230 300 2.3 */
398 { 0x9, 0x7F, 0x38, 0x00, 0x07 }, /* 269 350 2.3 */
399 { 0xA, 0x66, 0x3C, 0x00, 0x03 }, /* 446 500 1.0 */
400 { 0xB, 0x70, 0x3C, 0x00, 0x03 }, /* 460 600 2.3 */
401 { 0xC, 0x75, 0x3C, 0x00, 0x03 }, /* 537 700 2.3 */
402 { 0x2, 0x7F, 0x3F, 0x00, 0x00 }, /* 400 400 0.0 */
403};
404
405/* Voltage Swing Programming for VccIO 0.95V for DP */
406static const struct cnl_ddi_buf_trans cnl_ddi_translations_dp_0_95V[] = {
407 /* NT mV Trans mV db */
408 { 0xA, 0x5D, 0x3F, 0x00, 0x00 }, /* 350 350 0.0 */
409 { 0xA, 0x6A, 0x38, 0x00, 0x07 }, /* 350 500 3.1 */
410 { 0xB, 0x7A, 0x32, 0x00, 0x0D }, /* 350 700 6.0 */
411 { 0x6, 0x7C, 0x2D, 0x00, 0x12 }, /* 350 900 8.2 */
412 { 0xA, 0x69, 0x3F, 0x00, 0x00 }, /* 500 500 0.0 */
413 { 0xB, 0x7A, 0x36, 0x00, 0x09 }, /* 500 700 2.9 */
414 { 0x6, 0x7C, 0x30, 0x00, 0x0F }, /* 500 900 5.1 */
415 { 0xB, 0x7D, 0x3C, 0x00, 0x03 }, /* 650 725 0.9 */
416 { 0x6, 0x7C, 0x34, 0x00, 0x0B }, /* 600 900 3.5 */
417 { 0x6, 0x7B, 0x3F, 0x00, 0x00 }, /* 900 900 0.0 */
418};
419
420/* Voltage Swing Programming for VccIO 0.95V for HDMI */
421static const struct cnl_ddi_buf_trans cnl_ddi_translations_hdmi_0_95V[] = {
422 /* NT mV Trans mV db */
423 { 0xA, 0x5C, 0x3F, 0x00, 0x00 }, /* 400 400 0.0 */
424 { 0xB, 0x69, 0x37, 0x00, 0x08 }, /* 400 600 3.5 */
425 { 0x5, 0x76, 0x31, 0x00, 0x0E }, /* 400 800 6.0 */
426 { 0xA, 0x5E, 0x3F, 0x00, 0x00 }, /* 450 450 0.0 */
427 { 0xB, 0x69, 0x3F, 0x00, 0x00 }, /* 600 600 0.0 */
428 { 0xB, 0x79, 0x35, 0x00, 0x0A }, /* 600 850 3.0 */
429 { 0x6, 0x7D, 0x32, 0x00, 0x0D }, /* 600 1000 4.4 */
430 { 0x5, 0x76, 0x3F, 0x00, 0x00 }, /* 800 800 0.0 */
431 { 0x6, 0x7D, 0x39, 0x00, 0x06 }, /* 800 1000 1.9 */
432 { 0x6, 0x7F, 0x39, 0x00, 0x06 }, /* 850 1050 1.8 */
433 { 0x6, 0x7F, 0x3F, 0x00, 0x00 }, /* 1050 1050 0.0 */
434};
435
436/* Voltage Swing Programming for VccIO 0.95V for eDP */
437static const struct cnl_ddi_buf_trans cnl_ddi_translations_edp_0_95V[] = {
438 /* NT mV Trans mV db */
439 { 0xA, 0x61, 0x3A, 0x00, 0x05 }, /* 384 500 2.3 */
440 { 0x0, 0x7F, 0x38, 0x00, 0x07 }, /* 153 200 2.3 */
441 { 0x8, 0x7F, 0x38, 0x00, 0x07 }, /* 192 250 2.3 */
442 { 0x1, 0x7F, 0x38, 0x00, 0x07 }, /* 230 300 2.3 */
443 { 0x9, 0x7F, 0x38, 0x00, 0x07 }, /* 269 350 2.3 */
444 { 0xA, 0x61, 0x3C, 0x00, 0x03 }, /* 446 500 1.0 */
445 { 0xB, 0x68, 0x39, 0x00, 0x06 }, /* 460 600 2.3 */
446 { 0xC, 0x6E, 0x39, 0x00, 0x06 }, /* 537 700 2.3 */
447 { 0x4, 0x7F, 0x3A, 0x00, 0x05 }, /* 460 600 2.3 */
448 { 0x2, 0x7F, 0x3F, 0x00, 0x00 }, /* 400 400 0.0 */
449};
450
451/* Voltage Swing Programming for VccIO 1.05V for DP */
452static const struct cnl_ddi_buf_trans cnl_ddi_translations_dp_1_05V[] = {
453 /* NT mV Trans mV db */
454 { 0xA, 0x58, 0x3F, 0x00, 0x00 }, /* 400 400 0.0 */
455 { 0xB, 0x64, 0x37, 0x00, 0x08 }, /* 400 600 3.5 */
456 { 0x5, 0x70, 0x31, 0x00, 0x0E }, /* 400 800 6.0 */
457 { 0x6, 0x7F, 0x2C, 0x00, 0x13 }, /* 400 1050 8.4 */
458 { 0xB, 0x64, 0x3F, 0x00, 0x00 }, /* 600 600 0.0 */
459 { 0x5, 0x73, 0x35, 0x00, 0x0A }, /* 600 850 3.0 */
460 { 0x6, 0x7F, 0x30, 0x00, 0x0F }, /* 550 1050 5.6 */
461 { 0x5, 0x76, 0x3E, 0x00, 0x01 }, /* 850 900 0.5 */
462 { 0x6, 0x7F, 0x36, 0x00, 0x09 }, /* 750 1050 2.9 */
463 { 0x6, 0x7F, 0x3F, 0x00, 0x00 }, /* 1050 1050 0.0 */
464};
465
466/* Voltage Swing Programming for VccIO 1.05V for HDMI */
467static const struct cnl_ddi_buf_trans cnl_ddi_translations_hdmi_1_05V[] = {
468 /* NT mV Trans mV db */
469 { 0xA, 0x58, 0x3F, 0x00, 0x00 }, /* 400 400 0.0 */
470 { 0xB, 0x64, 0x37, 0x00, 0x08 }, /* 400 600 3.5 */
471 { 0x5, 0x70, 0x31, 0x00, 0x0E }, /* 400 800 6.0 */
472 { 0xA, 0x5B, 0x3F, 0x00, 0x00 }, /* 450 450 0.0 */
473 { 0xB, 0x64, 0x3F, 0x00, 0x00 }, /* 600 600 0.0 */
474 { 0x5, 0x73, 0x35, 0x00, 0x0A }, /* 600 850 3.0 */
475 { 0x6, 0x7C, 0x32, 0x00, 0x0D }, /* 600 1000 4.4 */
476 { 0x5, 0x70, 0x3F, 0x00, 0x00 }, /* 800 800 0.0 */
477 { 0x6, 0x7C, 0x39, 0x00, 0x06 }, /* 800 1000 1.9 */
478 { 0x6, 0x7F, 0x39, 0x00, 0x06 }, /* 850 1050 1.8 */
479 { 0x6, 0x7F, 0x3F, 0x00, 0x00 }, /* 1050 1050 0.0 */
480};
481
482/* Voltage Swing Programming for VccIO 1.05V for eDP */
483static const struct cnl_ddi_buf_trans cnl_ddi_translations_edp_1_05V[] = {
484 /* NT mV Trans mV db */
485 { 0xA, 0x5E, 0x3A, 0x00, 0x05 }, /* 384 500 2.3 */
486 { 0x0, 0x7F, 0x38, 0x00, 0x07 }, /* 153 200 2.3 */
487 { 0x8, 0x7F, 0x38, 0x00, 0x07 }, /* 192 250 2.3 */
488 { 0x1, 0x7F, 0x38, 0x00, 0x07 }, /* 230 300 2.3 */
489 { 0x9, 0x7F, 0x38, 0x00, 0x07 }, /* 269 350 2.3 */
490 { 0xA, 0x5E, 0x3C, 0x00, 0x03 }, /* 446 500 1.0 */
491 { 0xB, 0x64, 0x39, 0x00, 0x06 }, /* 460 600 2.3 */
492 { 0xE, 0x6A, 0x39, 0x00, 0x06 }, /* 537 700 2.3 */
493 { 0x2, 0x7F, 0x3F, 0x00, 0x00 }, /* 400 400 0.0 */
494};
495
496static const struct ddi_buf_trans *
497bdw_get_buf_trans_edp(struct drm_i915_private *dev_priv, int *n_entries)
498{
499 if (dev_priv->vbt.edp.low_vswing) {
500 *n_entries = ARRAY_SIZE(bdw_ddi_translations_edp);
501 return bdw_ddi_translations_edp;
502 } else {
503 *n_entries = ARRAY_SIZE(bdw_ddi_translations_dp);
504 return bdw_ddi_translations_dp;
505 }
506}
507
508static const struct ddi_buf_trans *
509skl_get_buf_trans_dp(struct drm_i915_private *dev_priv, int *n_entries)
510{
511 if (IS_SKL_ULX(dev_priv)) {
512 *n_entries = ARRAY_SIZE(skl_y_ddi_translations_dp);
513 return skl_y_ddi_translations_dp;
514 } else if (IS_SKL_ULT(dev_priv)) {
515 *n_entries = ARRAY_SIZE(skl_u_ddi_translations_dp);
516 return skl_u_ddi_translations_dp;
517 } else {
518 *n_entries = ARRAY_SIZE(skl_ddi_translations_dp);
519 return skl_ddi_translations_dp;
520 }
521}
522
523static const struct ddi_buf_trans *
524kbl_get_buf_trans_dp(struct drm_i915_private *dev_priv, int *n_entries)
525{
526 if (IS_KBL_ULX(dev_priv)) {
527 *n_entries = ARRAY_SIZE(kbl_y_ddi_translations_dp);
528 return kbl_y_ddi_translations_dp;
529 } else if (IS_KBL_ULT(dev_priv) || IS_CFL_ULT(dev_priv)) {
530 *n_entries = ARRAY_SIZE(kbl_u_ddi_translations_dp);
531 return kbl_u_ddi_translations_dp;
532 } else {
533 *n_entries = ARRAY_SIZE(kbl_ddi_translations_dp);
534 return kbl_ddi_translations_dp;
535 }
536}
537
538static const struct ddi_buf_trans *
539skl_get_buf_trans_edp(struct drm_i915_private *dev_priv, int *n_entries)
540{
541 if (dev_priv->vbt.edp.low_vswing) {
542 if (IS_SKL_ULX(dev_priv) || IS_KBL_ULX(dev_priv)) {
543 *n_entries = ARRAY_SIZE(skl_y_ddi_translations_edp);
544 return skl_y_ddi_translations_edp;
545 } else if (IS_SKL_ULT(dev_priv) || IS_KBL_ULT(dev_priv) ||
546 IS_CFL_ULT(dev_priv)) {
547 *n_entries = ARRAY_SIZE(skl_u_ddi_translations_edp);
548 return skl_u_ddi_translations_edp;
549 } else {
550 *n_entries = ARRAY_SIZE(skl_ddi_translations_edp);
551 return skl_ddi_translations_edp;
552 }
553 }
554
555 if (IS_KABYLAKE(dev_priv) || IS_COFFEELAKE(dev_priv))
556 return kbl_get_buf_trans_dp(dev_priv, n_entries);
557 else
558 return skl_get_buf_trans_dp(dev_priv, n_entries);
559}
560
561static const struct ddi_buf_trans *
562skl_get_buf_trans_hdmi(struct drm_i915_private *dev_priv, int *n_entries)
563{
564 if (IS_SKL_ULX(dev_priv) || IS_KBL_ULX(dev_priv)) {
565 *n_entries = ARRAY_SIZE(skl_y_ddi_translations_hdmi);
566 return skl_y_ddi_translations_hdmi;
567 } else {
568 *n_entries = ARRAY_SIZE(skl_ddi_translations_hdmi);
569 return skl_ddi_translations_hdmi;
570 }
571}
572
573static int skl_buf_trans_num_entries(enum port port, int n_entries)
574{
575 /* Only DDIA and DDIE can select the 10th register with DP */
576 if (port == PORT_A || port == PORT_E)
577 return min(n_entries, 10);
578 else
579 return min(n_entries, 9);
580}
581
582static const struct ddi_buf_trans *
583intel_ddi_get_buf_trans_dp(struct drm_i915_private *dev_priv,
584 enum port port, int *n_entries)
585{
586 if (IS_KABYLAKE(dev_priv) || IS_COFFEELAKE(dev_priv)) {
587 const struct ddi_buf_trans *ddi_translations =
588 kbl_get_buf_trans_dp(dev_priv, n_entries);
589 *n_entries = skl_buf_trans_num_entries(port, *n_entries);
590 return ddi_translations;
591 } else if (IS_SKYLAKE(dev_priv)) {
592 const struct ddi_buf_trans *ddi_translations =
593 skl_get_buf_trans_dp(dev_priv, n_entries);
594 *n_entries = skl_buf_trans_num_entries(port, *n_entries);
595 return ddi_translations;
596 } else if (IS_BROADWELL(dev_priv)) {
597 *n_entries = ARRAY_SIZE(bdw_ddi_translations_dp);
598 return bdw_ddi_translations_dp;
599 } else if (IS_HASWELL(dev_priv)) {
600 *n_entries = ARRAY_SIZE(hsw_ddi_translations_dp);
601 return hsw_ddi_translations_dp;
602 }
603
604 *n_entries = 0;
605 return NULL;
606}
607
608static const struct ddi_buf_trans *
609intel_ddi_get_buf_trans_edp(struct drm_i915_private *dev_priv,
610 enum port port, int *n_entries)
611{
612 if (IS_GEN9_BC(dev_priv)) {
613 const struct ddi_buf_trans *ddi_translations =
614 skl_get_buf_trans_edp(dev_priv, n_entries);
615 *n_entries = skl_buf_trans_num_entries(port, *n_entries);
616 return ddi_translations;
617 } else if (IS_BROADWELL(dev_priv)) {
618 return bdw_get_buf_trans_edp(dev_priv, n_entries);
619 } else if (IS_HASWELL(dev_priv)) {
620 *n_entries = ARRAY_SIZE(hsw_ddi_translations_dp);
621 return hsw_ddi_translations_dp;
622 }
623
624 *n_entries = 0;
625 return NULL;
626}
627
628static const struct ddi_buf_trans *
629intel_ddi_get_buf_trans_fdi(struct drm_i915_private *dev_priv,
630 int *n_entries)
631{
632 if (IS_BROADWELL(dev_priv)) {
633 *n_entries = ARRAY_SIZE(bdw_ddi_translations_fdi);
634 return bdw_ddi_translations_fdi;
635 } else if (IS_HASWELL(dev_priv)) {
636 *n_entries = ARRAY_SIZE(hsw_ddi_translations_fdi);
637 return hsw_ddi_translations_fdi;
638 }
639
640 *n_entries = 0;
641 return NULL;
642}
643
644static const struct ddi_buf_trans *
645intel_ddi_get_buf_trans_hdmi(struct drm_i915_private *dev_priv,
646 int *n_entries)
647{
648 if (IS_GEN9_BC(dev_priv)) {
649 return skl_get_buf_trans_hdmi(dev_priv, n_entries);
650 } else if (IS_BROADWELL(dev_priv)) {
651 *n_entries = ARRAY_SIZE(bdw_ddi_translations_hdmi);
652 return bdw_ddi_translations_hdmi;
653 } else if (IS_HASWELL(dev_priv)) {
654 *n_entries = ARRAY_SIZE(hsw_ddi_translations_hdmi);
655 return hsw_ddi_translations_hdmi;
656 }
657
658 *n_entries = 0;
659 return NULL;
660}
661
662static const struct bxt_ddi_buf_trans *
663bxt_get_buf_trans_dp(struct drm_i915_private *dev_priv, int *n_entries)
664{
665 *n_entries = ARRAY_SIZE(bxt_ddi_translations_dp);
666 return bxt_ddi_translations_dp;
667}
668
669static const struct bxt_ddi_buf_trans *
670bxt_get_buf_trans_edp(struct drm_i915_private *dev_priv, int *n_entries)
671{
672 if (dev_priv->vbt.edp.low_vswing) {
673 *n_entries = ARRAY_SIZE(bxt_ddi_translations_edp);
674 return bxt_ddi_translations_edp;
675 }
676
677 return bxt_get_buf_trans_dp(dev_priv, n_entries);
678}
679
680static const struct bxt_ddi_buf_trans *
681bxt_get_buf_trans_hdmi(struct drm_i915_private *dev_priv, int *n_entries)
682{
683 *n_entries = ARRAY_SIZE(bxt_ddi_translations_hdmi);
684 return bxt_ddi_translations_hdmi;
685}
686
687static const struct cnl_ddi_buf_trans *
688cnl_get_buf_trans_hdmi(struct drm_i915_private *dev_priv, int *n_entries)
689{
690 u32 voltage = I915_READ(CNL_PORT_COMP_DW3) & VOLTAGE_INFO_MASK;
691
692 if (voltage == VOLTAGE_INFO_0_85V) {
693 *n_entries = ARRAY_SIZE(cnl_ddi_translations_hdmi_0_85V);
694 return cnl_ddi_translations_hdmi_0_85V;
695 } else if (voltage == VOLTAGE_INFO_0_95V) {
696 *n_entries = ARRAY_SIZE(cnl_ddi_translations_hdmi_0_95V);
697 return cnl_ddi_translations_hdmi_0_95V;
698 } else if (voltage == VOLTAGE_INFO_1_05V) {
699 *n_entries = ARRAY_SIZE(cnl_ddi_translations_hdmi_1_05V);
700 return cnl_ddi_translations_hdmi_1_05V;
701 } else {
702 *n_entries = 1; /* shut up gcc */
703 MISSING_CASE(voltage);
704 }
705 return NULL;
706}
707
708static const struct cnl_ddi_buf_trans *
709cnl_get_buf_trans_dp(struct drm_i915_private *dev_priv, int *n_entries)
710{
711 u32 voltage = I915_READ(CNL_PORT_COMP_DW3) & VOLTAGE_INFO_MASK;
712
713 if (voltage == VOLTAGE_INFO_0_85V) {
714 *n_entries = ARRAY_SIZE(cnl_ddi_translations_dp_0_85V);
715 return cnl_ddi_translations_dp_0_85V;
716 } else if (voltage == VOLTAGE_INFO_0_95V) {
717 *n_entries = ARRAY_SIZE(cnl_ddi_translations_dp_0_95V);
718 return cnl_ddi_translations_dp_0_95V;
719 } else if (voltage == VOLTAGE_INFO_1_05V) {
720 *n_entries = ARRAY_SIZE(cnl_ddi_translations_dp_1_05V);
721 return cnl_ddi_translations_dp_1_05V;
722 } else {
723 *n_entries = 1; /* shut up gcc */
724 MISSING_CASE(voltage);
725 }
726 return NULL;
727}
728
729static const struct cnl_ddi_buf_trans *
730cnl_get_buf_trans_edp(struct drm_i915_private *dev_priv, int *n_entries)
731{
732 u32 voltage = I915_READ(CNL_PORT_COMP_DW3) & VOLTAGE_INFO_MASK;
733
734 if (dev_priv->vbt.edp.low_vswing) {
735 if (voltage == VOLTAGE_INFO_0_85V) {
736 *n_entries = ARRAY_SIZE(cnl_ddi_translations_edp_0_85V);
737 return cnl_ddi_translations_edp_0_85V;
738 } else if (voltage == VOLTAGE_INFO_0_95V) {
739 *n_entries = ARRAY_SIZE(cnl_ddi_translations_edp_0_95V);
740 return cnl_ddi_translations_edp_0_95V;
741 } else if (voltage == VOLTAGE_INFO_1_05V) {
742 *n_entries = ARRAY_SIZE(cnl_ddi_translations_edp_1_05V);
743 return cnl_ddi_translations_edp_1_05V;
744 } else {
745 *n_entries = 1; /* shut up gcc */
746 MISSING_CASE(voltage);
747 }
748 return NULL;
749 } else {
750 return cnl_get_buf_trans_dp(dev_priv, n_entries);
751 }
752}
753
754static int intel_ddi_hdmi_level(struct drm_i915_private *dev_priv, enum port port)
755{
756 int n_entries, level, default_entry;
757
758 level = dev_priv->vbt.ddi_port_info[port].hdmi_level_shift;
759
760 if (IS_CANNONLAKE(dev_priv)) {
761 cnl_get_buf_trans_hdmi(dev_priv, &n_entries);
762 default_entry = n_entries - 1;
763 } else if (IS_GEN9_LP(dev_priv)) {
764 bxt_get_buf_trans_hdmi(dev_priv, &n_entries);
765 default_entry = n_entries - 1;
766 } else if (IS_GEN9_BC(dev_priv)) {
767 intel_ddi_get_buf_trans_hdmi(dev_priv, &n_entries);
768 default_entry = 8;
769 } else if (IS_BROADWELL(dev_priv)) {
770 intel_ddi_get_buf_trans_hdmi(dev_priv, &n_entries);
771 default_entry = 7;
772 } else if (IS_HASWELL(dev_priv)) {
773 intel_ddi_get_buf_trans_hdmi(dev_priv, &n_entries);
774 default_entry = 6;
775 } else {
776 WARN(1, "ddi translation table missing\n");
777 return 0;
778 }
779
780 /* Choose a good default if VBT is badly populated */
781 if (level == HDMI_LEVEL_SHIFT_UNKNOWN || level >= n_entries)
782 level = default_entry;
783
784 if (WARN_ON_ONCE(n_entries == 0))
785 return 0;
786 if (WARN_ON_ONCE(level >= n_entries))
787 level = n_entries - 1;
788
789 return level;
790}
791
792/*
793 * Starting with Haswell, DDI port buffers must be programmed with correct
794 * values in advance. This function programs the correct values for
795 * DP/eDP/FDI use cases.
796 */
797static void intel_prepare_dp_ddi_buffers(struct intel_encoder *encoder,
798 const struct intel_crtc_state *crtc_state)
799{
800 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
801 u32 iboost_bit = 0;
802 int i, n_entries;
803 enum port port = encoder->port;
804 const struct ddi_buf_trans *ddi_translations;
805
806 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_ANALOG))
807 ddi_translations = intel_ddi_get_buf_trans_fdi(dev_priv,
808 &n_entries);
809 else if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_EDP))
810 ddi_translations = intel_ddi_get_buf_trans_edp(dev_priv, port,
811 &n_entries);
812 else
813 ddi_translations = intel_ddi_get_buf_trans_dp(dev_priv, port,
814 &n_entries);
815
816 /* If we're boosting the current, set bit 31 of trans1 */
817 if (IS_GEN9_BC(dev_priv) &&
818 dev_priv->vbt.ddi_port_info[port].dp_boost_level)
819 iboost_bit = DDI_BUF_BALANCE_LEG_ENABLE;
820
821 for (i = 0; i < n_entries; i++) {
822 I915_WRITE(DDI_BUF_TRANS_LO(port, i),
823 ddi_translations[i].trans1 | iboost_bit);
824 I915_WRITE(DDI_BUF_TRANS_HI(port, i),
825 ddi_translations[i].trans2);
826 }
827}
828
829/*
830 * Starting with Haswell, DDI port buffers must be programmed with correct
831 * values in advance. This function programs the correct values for
832 * HDMI/DVI use cases.
833 */
834static void intel_prepare_hdmi_ddi_buffers(struct intel_encoder *encoder,
835 int level)
836{
837 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
838 u32 iboost_bit = 0;
839 int n_entries;
840 enum port port = encoder->port;
841 const struct ddi_buf_trans *ddi_translations;
842
843 ddi_translations = intel_ddi_get_buf_trans_hdmi(dev_priv, &n_entries);
844
845 if (WARN_ON_ONCE(!ddi_translations))
846 return;
847 if (WARN_ON_ONCE(level >= n_entries))
848 level = n_entries - 1;
849
850 /* If we're boosting the current, set bit 31 of trans1 */
851 if (IS_GEN9_BC(dev_priv) &&
852 dev_priv->vbt.ddi_port_info[port].hdmi_boost_level)
853 iboost_bit = DDI_BUF_BALANCE_LEG_ENABLE;
854
855 /* Entry 9 is for HDMI: */
856 I915_WRITE(DDI_BUF_TRANS_LO(port, 9),
857 ddi_translations[level].trans1 | iboost_bit);
858 I915_WRITE(DDI_BUF_TRANS_HI(port, 9),
859 ddi_translations[level].trans2);
860}
861
862static void intel_wait_ddi_buf_idle(struct drm_i915_private *dev_priv,
863 enum port port)
864{
865 i915_reg_t reg = DDI_BUF_CTL(port);
866 int i;
867
868 for (i = 0; i < 16; i++) {
869 udelay(1);
870 if (I915_READ(reg) & DDI_BUF_IS_IDLE)
871 return;
872 }
873 DRM_ERROR("Timeout waiting for DDI BUF %c idle bit\n", port_name(port));
874}
875
876static uint32_t hsw_pll_to_ddi_pll_sel(const struct intel_shared_dpll *pll)
877{
878 switch (pll->id) {
879 case DPLL_ID_WRPLL1:
880 return PORT_CLK_SEL_WRPLL1;
881 case DPLL_ID_WRPLL2:
882 return PORT_CLK_SEL_WRPLL2;
883 case DPLL_ID_SPLL:
884 return PORT_CLK_SEL_SPLL;
885 case DPLL_ID_LCPLL_810:
886 return PORT_CLK_SEL_LCPLL_810;
887 case DPLL_ID_LCPLL_1350:
888 return PORT_CLK_SEL_LCPLL_1350;
889 case DPLL_ID_LCPLL_2700:
890 return PORT_CLK_SEL_LCPLL_2700;
891 default:
892 MISSING_CASE(pll->id);
893 return PORT_CLK_SEL_NONE;
894 }
895}
896
897/* Starting with Haswell, different DDI ports can work in FDI mode for
898 * connection to the PCH-located connectors. For this, it is necessary to train
899 * both the DDI port and PCH receiver for the desired DDI buffer settings.
900 *
901 * The recommended port to work in FDI mode is DDI E, which we use here. Also,
902 * please note that when FDI mode is active on DDI E, it shares 2 lines with
903 * DDI A (which is used for eDP)
904 */
905
906void hsw_fdi_link_train(struct intel_crtc *crtc,
907 const struct intel_crtc_state *crtc_state)
908{
909 struct drm_device *dev = crtc->base.dev;
910 struct drm_i915_private *dev_priv = to_i915(dev);
911 struct intel_encoder *encoder;
912 u32 temp, i, rx_ctl_val, ddi_pll_sel;
913
914 for_each_encoder_on_crtc(dev, &crtc->base, encoder) {
915 WARN_ON(encoder->type != INTEL_OUTPUT_ANALOG);
916 intel_prepare_dp_ddi_buffers(encoder, crtc_state);
917 }
918
919 /* Set the FDI_RX_MISC pwrdn lanes and the 2 workarounds listed at the
920 * mode set "sequence for CRT port" document:
921 * - TP1 to TP2 time with the default value
922 * - FDI delay to 90h
923 *
924 * WaFDIAutoLinkSetTimingOverrride:hsw
925 */
926 I915_WRITE(FDI_RX_MISC(PIPE_A), FDI_RX_PWRDN_LANE1_VAL(2) |
927 FDI_RX_PWRDN_LANE0_VAL(2) |
928 FDI_RX_TP1_TO_TP2_48 | FDI_RX_FDI_DELAY_90);
929
930 /* Enable the PCH Receiver FDI PLL */
931 rx_ctl_val = dev_priv->fdi_rx_config | FDI_RX_ENHANCE_FRAME_ENABLE |
932 FDI_RX_PLL_ENABLE |
933 FDI_DP_PORT_WIDTH(crtc_state->fdi_lanes);
934 I915_WRITE(FDI_RX_CTL(PIPE_A), rx_ctl_val);
935 POSTING_READ(FDI_RX_CTL(PIPE_A));
936 udelay(220);
937
938 /* Switch from Rawclk to PCDclk */
939 rx_ctl_val |= FDI_PCDCLK;
940 I915_WRITE(FDI_RX_CTL(PIPE_A), rx_ctl_val);
941
942 /* Configure Port Clock Select */
943 ddi_pll_sel = hsw_pll_to_ddi_pll_sel(crtc_state->shared_dpll);
944 I915_WRITE(PORT_CLK_SEL(PORT_E), ddi_pll_sel);
945 WARN_ON(ddi_pll_sel != PORT_CLK_SEL_SPLL);
946
947 /* Start the training iterating through available voltages and emphasis,
948 * testing each value twice. */
949 for (i = 0; i < ARRAY_SIZE(hsw_ddi_translations_fdi) * 2; i++) {
950 /* Configure DP_TP_CTL with auto-training */
951 I915_WRITE(DP_TP_CTL(PORT_E),
952 DP_TP_CTL_FDI_AUTOTRAIN |
953 DP_TP_CTL_ENHANCED_FRAME_ENABLE |
954 DP_TP_CTL_LINK_TRAIN_PAT1 |
955 DP_TP_CTL_ENABLE);
956
957 /* Configure and enable DDI_BUF_CTL for DDI E with next voltage.
958 * DDI E does not support port reversal, the functionality is
959 * achieved on the PCH side in FDI_RX_CTL, so no need to set the
960 * port reversal bit */
961 I915_WRITE(DDI_BUF_CTL(PORT_E),
962 DDI_BUF_CTL_ENABLE |
963 ((crtc_state->fdi_lanes - 1) << 1) |
964 DDI_BUF_TRANS_SELECT(i / 2));
965 POSTING_READ(DDI_BUF_CTL(PORT_E));
966
967 udelay(600);
968
969 /* Program PCH FDI Receiver TU */
970 I915_WRITE(FDI_RX_TUSIZE1(PIPE_A), TU_SIZE(64));
971
972 /* Enable PCH FDI Receiver with auto-training */
973 rx_ctl_val |= FDI_RX_ENABLE | FDI_LINK_TRAIN_AUTO;
974 I915_WRITE(FDI_RX_CTL(PIPE_A), rx_ctl_val);
975 POSTING_READ(FDI_RX_CTL(PIPE_A));
976
977 /* Wait for FDI receiver lane calibration */
978 udelay(30);
979
980 /* Unset FDI_RX_MISC pwrdn lanes */
981 temp = I915_READ(FDI_RX_MISC(PIPE_A));
982 temp &= ~(FDI_RX_PWRDN_LANE1_MASK | FDI_RX_PWRDN_LANE0_MASK);
983 I915_WRITE(FDI_RX_MISC(PIPE_A), temp);
984 POSTING_READ(FDI_RX_MISC(PIPE_A));
985
986 /* Wait for FDI auto training time */
987 udelay(5);
988
989 temp = I915_READ(DP_TP_STATUS(PORT_E));
990 if (temp & DP_TP_STATUS_AUTOTRAIN_DONE) {
991 DRM_DEBUG_KMS("FDI link training done on step %d\n", i);
992 break;
993 }
994
995 /*
996 * Leave things enabled even if we failed to train FDI.
997 * Results in less fireworks from the state checker.
998 */
999 if (i == ARRAY_SIZE(hsw_ddi_translations_fdi) * 2 - 1) {
1000 DRM_ERROR("FDI link training failed!\n");
1001 break;
1002 }
1003
1004 rx_ctl_val &= ~FDI_RX_ENABLE;
1005 I915_WRITE(FDI_RX_CTL(PIPE_A), rx_ctl_val);
1006 POSTING_READ(FDI_RX_CTL(PIPE_A));
1007
1008 temp = I915_READ(DDI_BUF_CTL(PORT_E));
1009 temp &= ~DDI_BUF_CTL_ENABLE;
1010 I915_WRITE(DDI_BUF_CTL(PORT_E), temp);
1011 POSTING_READ(DDI_BUF_CTL(PORT_E));
1012
1013 /* Disable DP_TP_CTL and FDI_RX_CTL and retry */
1014 temp = I915_READ(DP_TP_CTL(PORT_E));
1015 temp &= ~(DP_TP_CTL_ENABLE | DP_TP_CTL_LINK_TRAIN_MASK);
1016 temp |= DP_TP_CTL_LINK_TRAIN_PAT1;
1017 I915_WRITE(DP_TP_CTL(PORT_E), temp);
1018 POSTING_READ(DP_TP_CTL(PORT_E));
1019
1020 intel_wait_ddi_buf_idle(dev_priv, PORT_E);
1021
1022 /* Reset FDI_RX_MISC pwrdn lanes */
1023 temp = I915_READ(FDI_RX_MISC(PIPE_A));
1024 temp &= ~(FDI_RX_PWRDN_LANE1_MASK | FDI_RX_PWRDN_LANE0_MASK);
1025 temp |= FDI_RX_PWRDN_LANE1_VAL(2) | FDI_RX_PWRDN_LANE0_VAL(2);
1026 I915_WRITE(FDI_RX_MISC(PIPE_A), temp);
1027 POSTING_READ(FDI_RX_MISC(PIPE_A));
1028 }
1029
1030 /* Enable normal pixel sending for FDI */
1031 I915_WRITE(DP_TP_CTL(PORT_E),
1032 DP_TP_CTL_FDI_AUTOTRAIN |
1033 DP_TP_CTL_LINK_TRAIN_NORMAL |
1034 DP_TP_CTL_ENHANCED_FRAME_ENABLE |
1035 DP_TP_CTL_ENABLE);
1036}
1037
1038static void intel_ddi_init_dp_buf_reg(struct intel_encoder *encoder)
1039{
1040 struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
1041 struct intel_digital_port *intel_dig_port =
1042 enc_to_dig_port(&encoder->base);
1043
1044 intel_dp->DP = intel_dig_port->saved_port_bits |
1045 DDI_BUF_CTL_ENABLE | DDI_BUF_TRANS_SELECT(0);
1046 intel_dp->DP |= DDI_PORT_WIDTH(intel_dp->lane_count);
1047}
1048
1049static struct intel_encoder *
1050intel_ddi_get_crtc_encoder(struct intel_crtc *crtc)
1051{
1052 struct drm_device *dev = crtc->base.dev;
1053 struct intel_encoder *encoder, *ret = NULL;
1054 int num_encoders = 0;
1055
1056 for_each_encoder_on_crtc(dev, &crtc->base, encoder) {
1057 ret = encoder;
1058 num_encoders++;
1059 }
1060
1061 if (num_encoders != 1)
1062 WARN(1, "%d encoders on crtc for pipe %c\n", num_encoders,
1063 pipe_name(crtc->pipe));
1064
1065 BUG_ON(ret == NULL);
1066 return ret;
1067}
1068
1069/* Finds the only possible encoder associated with the given CRTC. */
1070struct intel_encoder *
1071intel_ddi_get_crtc_new_encoder(struct intel_crtc_state *crtc_state)
1072{
1073 struct intel_crtc *crtc = to_intel_crtc(crtc_state->base.crtc);
1074 struct intel_encoder *ret = NULL;
1075 struct drm_atomic_state *state;
1076 struct drm_connector *connector;
1077 struct drm_connector_state *connector_state;
1078 int num_encoders = 0;
1079 int i;
1080
1081 state = crtc_state->base.state;
1082
1083 for_each_new_connector_in_state(state, connector, connector_state, i) {
1084 if (connector_state->crtc != crtc_state->base.crtc)
1085 continue;
1086
1087 ret = to_intel_encoder(connector_state->best_encoder);
1088 num_encoders++;
1089 }
1090
1091 WARN(num_encoders != 1, "%d encoders on crtc for pipe %c\n", num_encoders,
1092 pipe_name(crtc->pipe));
1093
1094 BUG_ON(ret == NULL);
1095 return ret;
1096}
1097
1098#define LC_FREQ 2700
1099
1100static int hsw_ddi_calc_wrpll_link(struct drm_i915_private *dev_priv,
1101 i915_reg_t reg)
1102{
1103 int refclk = LC_FREQ;
1104 int n, p, r;
1105 u32 wrpll;
1106
1107 wrpll = I915_READ(reg);
1108 switch (wrpll & WRPLL_PLL_REF_MASK) {
1109 case WRPLL_PLL_SSC:
1110 case WRPLL_PLL_NON_SSC:
1111 /*
1112 * We could calculate spread here, but our checking
1113 * code only cares about 5% accuracy, and spread is a max of
1114 * 0.5% downspread.
1115 */
1116 refclk = 135;
1117 break;
1118 case WRPLL_PLL_LCPLL:
1119 refclk = LC_FREQ;
1120 break;
1121 default:
1122 WARN(1, "bad wrpll refclk\n");
1123 return 0;
1124 }
1125
1126 r = wrpll & WRPLL_DIVIDER_REF_MASK;
1127 p = (wrpll & WRPLL_DIVIDER_POST_MASK) >> WRPLL_DIVIDER_POST_SHIFT;
1128 n = (wrpll & WRPLL_DIVIDER_FB_MASK) >> WRPLL_DIVIDER_FB_SHIFT;
1129
1130 /* Convert to KHz, p & r have a fixed point portion */
1131 return (refclk * n * 100) / (p * r);
1132}
1133
1134static int skl_calc_wrpll_link(struct drm_i915_private *dev_priv,
1135 enum intel_dpll_id pll_id)
1136{
1137 i915_reg_t cfgcr1_reg, cfgcr2_reg;
1138 uint32_t cfgcr1_val, cfgcr2_val;
1139 uint32_t p0, p1, p2, dco_freq;
1140
1141 cfgcr1_reg = DPLL_CFGCR1(pll_id);
1142 cfgcr2_reg = DPLL_CFGCR2(pll_id);
1143
1144 cfgcr1_val = I915_READ(cfgcr1_reg);
1145 cfgcr2_val = I915_READ(cfgcr2_reg);
1146
1147 p0 = cfgcr2_val & DPLL_CFGCR2_PDIV_MASK;
1148 p2 = cfgcr2_val & DPLL_CFGCR2_KDIV_MASK;
1149
1150 if (cfgcr2_val & DPLL_CFGCR2_QDIV_MODE(1))
1151 p1 = (cfgcr2_val & DPLL_CFGCR2_QDIV_RATIO_MASK) >> 8;
1152 else
1153 p1 = 1;
1154
1155
1156 switch (p0) {
1157 case DPLL_CFGCR2_PDIV_1:
1158 p0 = 1;
1159 break;
1160 case DPLL_CFGCR2_PDIV_2:
1161 p0 = 2;
1162 break;
1163 case DPLL_CFGCR2_PDIV_3:
1164 p0 = 3;
1165 break;
1166 case DPLL_CFGCR2_PDIV_7:
1167 p0 = 7;
1168 break;
1169 }
1170
1171 switch (p2) {
1172 case DPLL_CFGCR2_KDIV_5:
1173 p2 = 5;
1174 break;
1175 case DPLL_CFGCR2_KDIV_2:
1176 p2 = 2;
1177 break;
1178 case DPLL_CFGCR2_KDIV_3:
1179 p2 = 3;
1180 break;
1181 case DPLL_CFGCR2_KDIV_1:
1182 p2 = 1;
1183 break;
1184 }
1185
1186 dco_freq = (cfgcr1_val & DPLL_CFGCR1_DCO_INTEGER_MASK) * 24 * 1000;
1187
1188 dco_freq += (((cfgcr1_val & DPLL_CFGCR1_DCO_FRACTION_MASK) >> 9) * 24 *
1189 1000) / 0x8000;
1190
1191 return dco_freq / (p0 * p1 * p2 * 5);
1192}
1193
1194static int cnl_calc_wrpll_link(struct drm_i915_private *dev_priv,
1195 enum intel_dpll_id pll_id)
1196{
1197 uint32_t cfgcr0, cfgcr1;
1198 uint32_t p0, p1, p2, dco_freq, ref_clock;
1199
1200 cfgcr0 = I915_READ(CNL_DPLL_CFGCR0(pll_id));
1201 cfgcr1 = I915_READ(CNL_DPLL_CFGCR1(pll_id));
1202
1203 p0 = cfgcr1 & DPLL_CFGCR1_PDIV_MASK;
1204 p2 = cfgcr1 & DPLL_CFGCR1_KDIV_MASK;
1205
1206 if (cfgcr1 & DPLL_CFGCR1_QDIV_MODE(1))
1207 p1 = (cfgcr1 & DPLL_CFGCR1_QDIV_RATIO_MASK) >>
1208 DPLL_CFGCR1_QDIV_RATIO_SHIFT;
1209 else
1210 p1 = 1;
1211
1212
1213 switch (p0) {
1214 case DPLL_CFGCR1_PDIV_2:
1215 p0 = 2;
1216 break;
1217 case DPLL_CFGCR1_PDIV_3:
1218 p0 = 3;
1219 break;
1220 case DPLL_CFGCR1_PDIV_5:
1221 p0 = 5;
1222 break;
1223 case DPLL_CFGCR1_PDIV_7:
1224 p0 = 7;
1225 break;
1226 }
1227
1228 switch (p2) {
1229 case DPLL_CFGCR1_KDIV_1:
1230 p2 = 1;
1231 break;
1232 case DPLL_CFGCR1_KDIV_2:
1233 p2 = 2;
1234 break;
1235 case DPLL_CFGCR1_KDIV_4:
1236 p2 = 4;
1237 break;
1238 }
1239
1240 ref_clock = dev_priv->cdclk.hw.ref;
1241
1242 dco_freq = (cfgcr0 & DPLL_CFGCR0_DCO_INTEGER_MASK) * ref_clock;
1243
1244 dco_freq += (((cfgcr0 & DPLL_CFGCR0_DCO_FRACTION_MASK) >>
1245 DPLL_CFGCR0_DCO_FRACTION_SHIFT) * ref_clock) / 0x8000;
1246
1247 if (WARN_ON(p0 == 0 || p1 == 0 || p2 == 0))
1248 return 0;
1249
1250 return dco_freq / (p0 * p1 * p2 * 5);
1251}
1252
1253static void ddi_dotclock_get(struct intel_crtc_state *pipe_config)
1254{
1255 int dotclock;
1256
1257 if (pipe_config->has_pch_encoder)
1258 dotclock = intel_dotclock_calculate(pipe_config->port_clock,
1259 &pipe_config->fdi_m_n);
1260 else if (intel_crtc_has_dp_encoder(pipe_config))
1261 dotclock = intel_dotclock_calculate(pipe_config->port_clock,
1262 &pipe_config->dp_m_n);
1263 else if (pipe_config->has_hdmi_sink && pipe_config->pipe_bpp == 36)
1264 dotclock = pipe_config->port_clock * 2 / 3;
1265 else
1266 dotclock = pipe_config->port_clock;
1267
1268 if (pipe_config->ycbcr420)
1269 dotclock *= 2;
1270
1271 if (pipe_config->pixel_multiplier)
1272 dotclock /= pipe_config->pixel_multiplier;
1273
1274 pipe_config->base.adjusted_mode.crtc_clock = dotclock;
1275}
1276
1277static void cnl_ddi_clock_get(struct intel_encoder *encoder,
1278 struct intel_crtc_state *pipe_config)
1279{
1280 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
1281 int link_clock = 0;
1282 uint32_t cfgcr0;
1283 enum intel_dpll_id pll_id;
1284
1285 pll_id = intel_get_shared_dpll_id(dev_priv, pipe_config->shared_dpll);
1286
1287 cfgcr0 = I915_READ(CNL_DPLL_CFGCR0(pll_id));
1288
1289 if (cfgcr0 & DPLL_CFGCR0_HDMI_MODE) {
1290 link_clock = cnl_calc_wrpll_link(dev_priv, pll_id);
1291 } else {
1292 link_clock = cfgcr0 & DPLL_CFGCR0_LINK_RATE_MASK;
1293
1294 switch (link_clock) {
1295 case DPLL_CFGCR0_LINK_RATE_810:
1296 link_clock = 81000;
1297 break;
1298 case DPLL_CFGCR0_LINK_RATE_1080:
1299 link_clock = 108000;
1300 break;
1301 case DPLL_CFGCR0_LINK_RATE_1350:
1302 link_clock = 135000;
1303 break;
1304 case DPLL_CFGCR0_LINK_RATE_1620:
1305 link_clock = 162000;
1306 break;
1307 case DPLL_CFGCR0_LINK_RATE_2160:
1308 link_clock = 216000;
1309 break;
1310 case DPLL_CFGCR0_LINK_RATE_2700:
1311 link_clock = 270000;
1312 break;
1313 case DPLL_CFGCR0_LINK_RATE_3240:
1314 link_clock = 324000;
1315 break;
1316 case DPLL_CFGCR0_LINK_RATE_4050:
1317 link_clock = 405000;
1318 break;
1319 default:
1320 WARN(1, "Unsupported link rate\n");
1321 break;
1322 }
1323 link_clock *= 2;
1324 }
1325
1326 pipe_config->port_clock = link_clock;
1327
1328 ddi_dotclock_get(pipe_config);
1329}
1330
1331static void skl_ddi_clock_get(struct intel_encoder *encoder,
1332 struct intel_crtc_state *pipe_config)
1333{
1334 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
1335 int link_clock = 0;
1336 uint32_t dpll_ctl1;
1337 enum intel_dpll_id pll_id;
1338
1339 pll_id = intel_get_shared_dpll_id(dev_priv, pipe_config->shared_dpll);
1340
1341 dpll_ctl1 = I915_READ(DPLL_CTRL1);
1342
1343 if (dpll_ctl1 & DPLL_CTRL1_HDMI_MODE(pll_id)) {
1344 link_clock = skl_calc_wrpll_link(dev_priv, pll_id);
1345 } else {
1346 link_clock = dpll_ctl1 & DPLL_CTRL1_LINK_RATE_MASK(pll_id);
1347 link_clock >>= DPLL_CTRL1_LINK_RATE_SHIFT(pll_id);
1348
1349 switch (link_clock) {
1350 case DPLL_CTRL1_LINK_RATE_810:
1351 link_clock = 81000;
1352 break;
1353 case DPLL_CTRL1_LINK_RATE_1080:
1354 link_clock = 108000;
1355 break;
1356 case DPLL_CTRL1_LINK_RATE_1350:
1357 link_clock = 135000;
1358 break;
1359 case DPLL_CTRL1_LINK_RATE_1620:
1360 link_clock = 162000;
1361 break;
1362 case DPLL_CTRL1_LINK_RATE_2160:
1363 link_clock = 216000;
1364 break;
1365 case DPLL_CTRL1_LINK_RATE_2700:
1366 link_clock = 270000;
1367 break;
1368 default:
1369 WARN(1, "Unsupported link rate\n");
1370 break;
1371 }
1372 link_clock *= 2;
1373 }
1374
1375 pipe_config->port_clock = link_clock;
1376
1377 ddi_dotclock_get(pipe_config);
1378}
1379
1380static void hsw_ddi_clock_get(struct intel_encoder *encoder,
1381 struct intel_crtc_state *pipe_config)
1382{
1383 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
1384 int link_clock = 0;
1385 u32 val, pll;
1386
1387 val = hsw_pll_to_ddi_pll_sel(pipe_config->shared_dpll);
1388 switch (val & PORT_CLK_SEL_MASK) {
1389 case PORT_CLK_SEL_LCPLL_810:
1390 link_clock = 81000;
1391 break;
1392 case PORT_CLK_SEL_LCPLL_1350:
1393 link_clock = 135000;
1394 break;
1395 case PORT_CLK_SEL_LCPLL_2700:
1396 link_clock = 270000;
1397 break;
1398 case PORT_CLK_SEL_WRPLL1:
1399 link_clock = hsw_ddi_calc_wrpll_link(dev_priv, WRPLL_CTL(0));
1400 break;
1401 case PORT_CLK_SEL_WRPLL2:
1402 link_clock = hsw_ddi_calc_wrpll_link(dev_priv, WRPLL_CTL(1));
1403 break;
1404 case PORT_CLK_SEL_SPLL:
1405 pll = I915_READ(SPLL_CTL) & SPLL_PLL_FREQ_MASK;
1406 if (pll == SPLL_PLL_FREQ_810MHz)
1407 link_clock = 81000;
1408 else if (pll == SPLL_PLL_FREQ_1350MHz)
1409 link_clock = 135000;
1410 else if (pll == SPLL_PLL_FREQ_2700MHz)
1411 link_clock = 270000;
1412 else {
1413 WARN(1, "bad spll freq\n");
1414 return;
1415 }
1416 break;
1417 default:
1418 WARN(1, "bad port clock sel\n");
1419 return;
1420 }
1421
1422 pipe_config->port_clock = link_clock * 2;
1423
1424 ddi_dotclock_get(pipe_config);
1425}
1426
1427static int bxt_calc_pll_link(struct intel_crtc_state *crtc_state)
1428{
1429 struct intel_dpll_hw_state *state;
1430 struct dpll clock;
1431
1432 /* For DDI ports we always use a shared PLL. */
1433 if (WARN_ON(!crtc_state->shared_dpll))
1434 return 0;
1435
1436 state = &crtc_state->dpll_hw_state;
1437
1438 clock.m1 = 2;
1439 clock.m2 = (state->pll0 & PORT_PLL_M2_MASK) << 22;
1440 if (state->pll3 & PORT_PLL_M2_FRAC_ENABLE)
1441 clock.m2 |= state->pll2 & PORT_PLL_M2_FRAC_MASK;
1442 clock.n = (state->pll1 & PORT_PLL_N_MASK) >> PORT_PLL_N_SHIFT;
1443 clock.p1 = (state->ebb0 & PORT_PLL_P1_MASK) >> PORT_PLL_P1_SHIFT;
1444 clock.p2 = (state->ebb0 & PORT_PLL_P2_MASK) >> PORT_PLL_P2_SHIFT;
1445
1446 return chv_calc_dpll_params(100000, &clock);
1447}
1448
1449static void bxt_ddi_clock_get(struct intel_encoder *encoder,
1450 struct intel_crtc_state *pipe_config)
1451{
1452 pipe_config->port_clock = bxt_calc_pll_link(pipe_config);
1453
1454 ddi_dotclock_get(pipe_config);
1455}
1456
1457static void intel_ddi_clock_get(struct intel_encoder *encoder,
1458 struct intel_crtc_state *pipe_config)
1459{
1460 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
1461
1462 if (INTEL_GEN(dev_priv) <= 8)
1463 hsw_ddi_clock_get(encoder, pipe_config);
1464 else if (IS_GEN9_BC(dev_priv))
1465 skl_ddi_clock_get(encoder, pipe_config);
1466 else if (IS_GEN9_LP(dev_priv))
1467 bxt_ddi_clock_get(encoder, pipe_config);
1468 else if (IS_CANNONLAKE(dev_priv))
1469 cnl_ddi_clock_get(encoder, pipe_config);
1470}
1471
1472void intel_ddi_set_pipe_settings(const struct intel_crtc_state *crtc_state)
1473{
1474 struct intel_crtc *crtc = to_intel_crtc(crtc_state->base.crtc);
1475 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
1476 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
1477 u32 temp;
1478
1479 if (!intel_crtc_has_dp_encoder(crtc_state))
1480 return;
1481
1482 WARN_ON(transcoder_is_dsi(cpu_transcoder));
1483
1484 temp = TRANS_MSA_SYNC_CLK;
1485 switch (crtc_state->pipe_bpp) {
1486 case 18:
1487 temp |= TRANS_MSA_6_BPC;
1488 break;
1489 case 24:
1490 temp |= TRANS_MSA_8_BPC;
1491 break;
1492 case 30:
1493 temp |= TRANS_MSA_10_BPC;
1494 break;
1495 case 36:
1496 temp |= TRANS_MSA_12_BPC;
1497 break;
1498 default:
1499 MISSING_CASE(crtc_state->pipe_bpp);
1500 break;
1501 }
1502
1503 I915_WRITE(TRANS_MSA_MISC(cpu_transcoder), temp);
1504}
1505
1506void intel_ddi_set_vc_payload_alloc(const struct intel_crtc_state *crtc_state,
1507 bool state)
1508{
1509 struct intel_crtc *crtc = to_intel_crtc(crtc_state->base.crtc);
1510 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
1511 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
1512 uint32_t temp;
1513
1514 temp = I915_READ(TRANS_DDI_FUNC_CTL(cpu_transcoder));
1515 if (state == true)
1516 temp |= TRANS_DDI_DP_VC_PAYLOAD_ALLOC;
1517 else
1518 temp &= ~TRANS_DDI_DP_VC_PAYLOAD_ALLOC;
1519 I915_WRITE(TRANS_DDI_FUNC_CTL(cpu_transcoder), temp);
1520}
1521
1522void intel_ddi_enable_transcoder_func(const struct intel_crtc_state *crtc_state)
1523{
1524 struct intel_crtc *crtc = to_intel_crtc(crtc_state->base.crtc);
1525 struct intel_encoder *encoder = intel_ddi_get_crtc_encoder(crtc);
1526 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
1527 enum pipe pipe = crtc->pipe;
1528 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
1529 enum port port = encoder->port;
1530 uint32_t temp;
1531
1532 /* Enable TRANS_DDI_FUNC_CTL for the pipe to work in HDMI mode */
1533 temp = TRANS_DDI_FUNC_ENABLE;
1534 temp |= TRANS_DDI_SELECT_PORT(port);
1535
1536 switch (crtc_state->pipe_bpp) {
1537 case 18:
1538 temp |= TRANS_DDI_BPC_6;
1539 break;
1540 case 24:
1541 temp |= TRANS_DDI_BPC_8;
1542 break;
1543 case 30:
1544 temp |= TRANS_DDI_BPC_10;
1545 break;
1546 case 36:
1547 temp |= TRANS_DDI_BPC_12;
1548 break;
1549 default:
1550 BUG();
1551 }
1552
1553 if (crtc_state->base.adjusted_mode.flags & DRM_MODE_FLAG_PVSYNC)
1554 temp |= TRANS_DDI_PVSYNC;
1555 if (crtc_state->base.adjusted_mode.flags & DRM_MODE_FLAG_PHSYNC)
1556 temp |= TRANS_DDI_PHSYNC;
1557
1558 if (cpu_transcoder == TRANSCODER_EDP) {
1559 switch (pipe) {
1560 case PIPE_A:
1561 /* On Haswell, can only use the always-on power well for
1562 * eDP when not using the panel fitter, and when not
1563 * using motion blur mitigation (which we don't
1564 * support). */
1565 if (IS_HASWELL(dev_priv) &&
1566 (crtc_state->pch_pfit.enabled ||
1567 crtc_state->pch_pfit.force_thru))
1568 temp |= TRANS_DDI_EDP_INPUT_A_ONOFF;
1569 else
1570 temp |= TRANS_DDI_EDP_INPUT_A_ON;
1571 break;
1572 case PIPE_B:
1573 temp |= TRANS_DDI_EDP_INPUT_B_ONOFF;
1574 break;
1575 case PIPE_C:
1576 temp |= TRANS_DDI_EDP_INPUT_C_ONOFF;
1577 break;
1578 default:
1579 BUG();
1580 break;
1581 }
1582 }
1583
1584 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI)) {
1585 if (crtc_state->has_hdmi_sink)
1586 temp |= TRANS_DDI_MODE_SELECT_HDMI;
1587 else
1588 temp |= TRANS_DDI_MODE_SELECT_DVI;
1589
1590 if (crtc_state->hdmi_scrambling)
1591 temp |= TRANS_DDI_HDMI_SCRAMBLING_MASK;
1592 if (crtc_state->hdmi_high_tmds_clock_ratio)
1593 temp |= TRANS_DDI_HIGH_TMDS_CHAR_RATE;
1594 } else if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_ANALOG)) {
1595 temp |= TRANS_DDI_MODE_SELECT_FDI;
1596 temp |= (crtc_state->fdi_lanes - 1) << 1;
1597 } else if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST)) {
1598 temp |= TRANS_DDI_MODE_SELECT_DP_MST;
1599 temp |= DDI_PORT_WIDTH(crtc_state->lane_count);
1600 } else {
1601 temp |= TRANS_DDI_MODE_SELECT_DP_SST;
1602 temp |= DDI_PORT_WIDTH(crtc_state->lane_count);
1603 }
1604
1605 I915_WRITE(TRANS_DDI_FUNC_CTL(cpu_transcoder), temp);
1606}
1607
1608void intel_ddi_disable_transcoder_func(struct drm_i915_private *dev_priv,
1609 enum transcoder cpu_transcoder)
1610{
1611 i915_reg_t reg = TRANS_DDI_FUNC_CTL(cpu_transcoder);
1612 uint32_t val = I915_READ(reg);
1613
1614 val &= ~(TRANS_DDI_FUNC_ENABLE | TRANS_DDI_PORT_MASK | TRANS_DDI_DP_VC_PAYLOAD_ALLOC);
1615 val |= TRANS_DDI_PORT_NONE;
1616 I915_WRITE(reg, val);
1617}
1618
1619int intel_ddi_toggle_hdcp_signalling(struct intel_encoder *intel_encoder,
1620 bool enable)
1621{
1622 struct drm_device *dev = intel_encoder->base.dev;
1623 struct drm_i915_private *dev_priv = to_i915(dev);
1624 enum pipe pipe = 0;
1625 int ret = 0;
1626 uint32_t tmp;
1627
1628 if (WARN_ON(!intel_display_power_get_if_enabled(dev_priv,
1629 intel_encoder->power_domain)))
1630 return -ENXIO;
1631
1632 if (WARN_ON(!intel_encoder->get_hw_state(intel_encoder, &pipe))) {
1633 ret = -EIO;
1634 goto out;
1635 }
1636
1637 tmp = I915_READ(TRANS_DDI_FUNC_CTL(pipe));
1638 if (enable)
1639 tmp |= TRANS_DDI_HDCP_SIGNALLING;
1640 else
1641 tmp &= ~TRANS_DDI_HDCP_SIGNALLING;
1642 I915_WRITE(TRANS_DDI_FUNC_CTL(pipe), tmp);
1643out:
1644 intel_display_power_put(dev_priv, intel_encoder->power_domain);
1645 return ret;
1646}
1647
1648bool intel_ddi_connector_get_hw_state(struct intel_connector *intel_connector)
1649{
1650 struct drm_device *dev = intel_connector->base.dev;
1651 struct drm_i915_private *dev_priv = to_i915(dev);
1652 struct intel_encoder *encoder = intel_connector->encoder;
1653 int type = intel_connector->base.connector_type;
1654 enum port port = encoder->port;
1655 enum pipe pipe = 0;
1656 enum transcoder cpu_transcoder;
1657 uint32_t tmp;
1658 bool ret;
1659
1660 if (!intel_display_power_get_if_enabled(dev_priv,
1661 encoder->power_domain))
1662 return false;
1663
1664 if (!encoder->get_hw_state(encoder, &pipe)) {
1665 ret = false;
1666 goto out;
1667 }
1668
1669 if (port == PORT_A)
1670 cpu_transcoder = TRANSCODER_EDP;
1671 else
1672 cpu_transcoder = (enum transcoder) pipe;
1673
1674 tmp = I915_READ(TRANS_DDI_FUNC_CTL(cpu_transcoder));
1675
1676 switch (tmp & TRANS_DDI_MODE_SELECT_MASK) {
1677 case TRANS_DDI_MODE_SELECT_HDMI:
1678 case TRANS_DDI_MODE_SELECT_DVI:
1679 ret = type == DRM_MODE_CONNECTOR_HDMIA;
1680 break;
1681
1682 case TRANS_DDI_MODE_SELECT_DP_SST:
1683 ret = type == DRM_MODE_CONNECTOR_eDP ||
1684 type == DRM_MODE_CONNECTOR_DisplayPort;
1685 break;
1686
1687 case TRANS_DDI_MODE_SELECT_DP_MST:
1688 /* if the transcoder is in MST state then
1689 * connector isn't connected */
1690 ret = false;
1691 break;
1692
1693 case TRANS_DDI_MODE_SELECT_FDI:
1694 ret = type == DRM_MODE_CONNECTOR_VGA;
1695 break;
1696
1697 default:
1698 ret = false;
1699 break;
1700 }
1701
1702out:
1703 intel_display_power_put(dev_priv, encoder->power_domain);
1704
1705 return ret;
1706}
1707
1708bool intel_ddi_get_hw_state(struct intel_encoder *encoder,
1709 enum pipe *pipe)
1710{
1711 struct drm_device *dev = encoder->base.dev;
1712 struct drm_i915_private *dev_priv = to_i915(dev);
1713 enum port port = encoder->port;
1714 enum pipe p;
1715 u32 tmp;
1716 bool ret;
1717
1718 if (!intel_display_power_get_if_enabled(dev_priv,
1719 encoder->power_domain))
1720 return false;
1721
1722 ret = false;
1723
1724 tmp = I915_READ(DDI_BUF_CTL(port));
1725
1726 if (!(tmp & DDI_BUF_CTL_ENABLE))
1727 goto out;
1728
1729 if (port == PORT_A) {
1730 tmp = I915_READ(TRANS_DDI_FUNC_CTL(TRANSCODER_EDP));
1731
1732 switch (tmp & TRANS_DDI_EDP_INPUT_MASK) {
1733 case TRANS_DDI_EDP_INPUT_A_ON:
1734 case TRANS_DDI_EDP_INPUT_A_ONOFF:
1735 *pipe = PIPE_A;
1736 break;
1737 case TRANS_DDI_EDP_INPUT_B_ONOFF:
1738 *pipe = PIPE_B;
1739 break;
1740 case TRANS_DDI_EDP_INPUT_C_ONOFF:
1741 *pipe = PIPE_C;
1742 break;
1743 }
1744
1745 ret = true;
1746
1747 goto out;
1748 }
1749
1750 for_each_pipe(dev_priv, p) {
1751 enum transcoder cpu_transcoder = (enum transcoder) p;
1752
1753 tmp = I915_READ(TRANS_DDI_FUNC_CTL(cpu_transcoder));
1754
1755 if ((tmp & TRANS_DDI_PORT_MASK) == TRANS_DDI_SELECT_PORT(port)) {
1756 if ((tmp & TRANS_DDI_MODE_SELECT_MASK) ==
1757 TRANS_DDI_MODE_SELECT_DP_MST)
1758 goto out;
1759
1760 *pipe = p;
1761 ret = true;
1762
1763 goto out;
1764 }
1765 }
1766
1767 DRM_DEBUG_KMS("No pipe for ddi port %c found\n", port_name(port));
1768
1769out:
1770 if (ret && IS_GEN9_LP(dev_priv)) {
1771 tmp = I915_READ(BXT_PHY_CTL(port));
1772 if ((tmp & (BXT_PHY_CMNLANE_POWERDOWN_ACK |
1773 BXT_PHY_LANE_POWERDOWN_ACK |
1774 BXT_PHY_LANE_ENABLED)) != BXT_PHY_LANE_ENABLED)
1775 DRM_ERROR("Port %c enabled but PHY powered down? "
1776 "(PHY_CTL %08x)\n", port_name(port), tmp);
1777 }
1778
1779 intel_display_power_put(dev_priv, encoder->power_domain);
1780
1781 return ret;
1782}
1783
1784static u64 intel_ddi_get_power_domains(struct intel_encoder *encoder)
1785{
1786 struct intel_digital_port *dig_port = enc_to_dig_port(&encoder->base);
1787 enum pipe pipe;
1788
1789 if (intel_ddi_get_hw_state(encoder, &pipe))
1790 return BIT_ULL(dig_port->ddi_io_power_domain);
1791
1792 return 0;
1793}
1794
1795void intel_ddi_enable_pipe_clock(const struct intel_crtc_state *crtc_state)
1796{
1797 struct intel_crtc *crtc = to_intel_crtc(crtc_state->base.crtc);
1798 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
1799 struct intel_encoder *encoder = intel_ddi_get_crtc_encoder(crtc);
1800 enum port port = encoder->port;
1801 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
1802
1803 if (cpu_transcoder != TRANSCODER_EDP)
1804 I915_WRITE(TRANS_CLK_SEL(cpu_transcoder),
1805 TRANS_CLK_SEL_PORT(port));
1806}
1807
1808void intel_ddi_disable_pipe_clock(const struct intel_crtc_state *crtc_state)
1809{
1810 struct drm_i915_private *dev_priv = to_i915(crtc_state->base.crtc->dev);
1811 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
1812
1813 if (cpu_transcoder != TRANSCODER_EDP)
1814 I915_WRITE(TRANS_CLK_SEL(cpu_transcoder),
1815 TRANS_CLK_SEL_DISABLED);
1816}
1817
1818static void _skl_ddi_set_iboost(struct drm_i915_private *dev_priv,
1819 enum port port, uint8_t iboost)
1820{
1821 u32 tmp;
1822
1823 tmp = I915_READ(DISPIO_CR_TX_BMU_CR0);
1824 tmp &= ~(BALANCE_LEG_MASK(port) | BALANCE_LEG_DISABLE(port));
1825 if (iboost)
1826 tmp |= iboost << BALANCE_LEG_SHIFT(port);
1827 else
1828 tmp |= BALANCE_LEG_DISABLE(port);
1829 I915_WRITE(DISPIO_CR_TX_BMU_CR0, tmp);
1830}
1831
1832static void skl_ddi_set_iboost(struct intel_encoder *encoder,
1833 int level, enum intel_output_type type)
1834{
1835 struct intel_digital_port *intel_dig_port = enc_to_dig_port(&encoder->base);
1836 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
1837 enum port port = encoder->port;
1838 uint8_t iboost;
1839
1840 if (type == INTEL_OUTPUT_HDMI)
1841 iboost = dev_priv->vbt.ddi_port_info[port].hdmi_boost_level;
1842 else
1843 iboost = dev_priv->vbt.ddi_port_info[port].dp_boost_level;
1844
1845 if (iboost == 0) {
1846 const struct ddi_buf_trans *ddi_translations;
1847 int n_entries;
1848
1849 if (type == INTEL_OUTPUT_HDMI)
1850 ddi_translations = intel_ddi_get_buf_trans_hdmi(dev_priv, &n_entries);
1851 else if (type == INTEL_OUTPUT_EDP)
1852 ddi_translations = intel_ddi_get_buf_trans_edp(dev_priv, port, &n_entries);
1853 else
1854 ddi_translations = intel_ddi_get_buf_trans_dp(dev_priv, port, &n_entries);
1855
1856 if (WARN_ON_ONCE(!ddi_translations))
1857 return;
1858 if (WARN_ON_ONCE(level >= n_entries))
1859 level = n_entries - 1;
1860
1861 iboost = ddi_translations[level].i_boost;
1862 }
1863
1864 /* Make sure that the requested I_boost is valid */
1865 if (iboost && iboost != 0x1 && iboost != 0x3 && iboost != 0x7) {
1866 DRM_ERROR("Invalid I_boost value %u\n", iboost);
1867 return;
1868 }
1869
1870 _skl_ddi_set_iboost(dev_priv, port, iboost);
1871
1872 if (port == PORT_A && intel_dig_port->max_lanes == 4)
1873 _skl_ddi_set_iboost(dev_priv, PORT_E, iboost);
1874}
1875
1876static void bxt_ddi_vswing_sequence(struct intel_encoder *encoder,
1877 int level, enum intel_output_type type)
1878{
1879 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
1880 const struct bxt_ddi_buf_trans *ddi_translations;
1881 enum port port = encoder->port;
1882 int n_entries;
1883
1884 if (type == INTEL_OUTPUT_HDMI)
1885 ddi_translations = bxt_get_buf_trans_hdmi(dev_priv, &n_entries);
1886 else if (type == INTEL_OUTPUT_EDP)
1887 ddi_translations = bxt_get_buf_trans_edp(dev_priv, &n_entries);
1888 else
1889 ddi_translations = bxt_get_buf_trans_dp(dev_priv, &n_entries);
1890
1891 if (WARN_ON_ONCE(!ddi_translations))
1892 return;
1893 if (WARN_ON_ONCE(level >= n_entries))
1894 level = n_entries - 1;
1895
1896 bxt_ddi_phy_set_signal_level(dev_priv, port,
1897 ddi_translations[level].margin,
1898 ddi_translations[level].scale,
1899 ddi_translations[level].enable,
1900 ddi_translations[level].deemphasis);
1901}
1902
1903u8 intel_ddi_dp_voltage_max(struct intel_encoder *encoder)
1904{
1905 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
1906 enum port port = encoder->port;
1907 int n_entries;
1908
1909 if (IS_CANNONLAKE(dev_priv)) {
1910 if (encoder->type == INTEL_OUTPUT_EDP)
1911 cnl_get_buf_trans_edp(dev_priv, &n_entries);
1912 else
1913 cnl_get_buf_trans_dp(dev_priv, &n_entries);
1914 } else if (IS_GEN9_LP(dev_priv)) {
1915 if (encoder->type == INTEL_OUTPUT_EDP)
1916 bxt_get_buf_trans_edp(dev_priv, &n_entries);
1917 else
1918 bxt_get_buf_trans_dp(dev_priv, &n_entries);
1919 } else {
1920 if (encoder->type == INTEL_OUTPUT_EDP)
1921 intel_ddi_get_buf_trans_edp(dev_priv, port, &n_entries);
1922 else
1923 intel_ddi_get_buf_trans_dp(dev_priv, port, &n_entries);
1924 }
1925
1926 if (WARN_ON(n_entries < 1))
1927 n_entries = 1;
1928 if (WARN_ON(n_entries > ARRAY_SIZE(index_to_dp_signal_levels)))
1929 n_entries = ARRAY_SIZE(index_to_dp_signal_levels);
1930
1931 return index_to_dp_signal_levels[n_entries - 1] &
1932 DP_TRAIN_VOLTAGE_SWING_MASK;
1933}
1934
1935static void cnl_ddi_vswing_program(struct intel_encoder *encoder,
1936 int level, enum intel_output_type type)
1937{
1938 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
1939 const struct cnl_ddi_buf_trans *ddi_translations;
1940 enum port port = encoder->port;
1941 int n_entries, ln;
1942 u32 val;
1943
1944 if (type == INTEL_OUTPUT_HDMI)
1945 ddi_translations = cnl_get_buf_trans_hdmi(dev_priv, &n_entries);
1946 else if (type == INTEL_OUTPUT_EDP)
1947 ddi_translations = cnl_get_buf_trans_edp(dev_priv, &n_entries);
1948 else
1949 ddi_translations = cnl_get_buf_trans_dp(dev_priv, &n_entries);
1950
1951 if (WARN_ON_ONCE(!ddi_translations))
1952 return;
1953 if (WARN_ON_ONCE(level >= n_entries))
1954 level = n_entries - 1;
1955
1956 /* Set PORT_TX_DW5 Scaling Mode Sel to 010b. */
1957 val = I915_READ(CNL_PORT_TX_DW5_LN0(port));
1958 val &= ~SCALING_MODE_SEL_MASK;
1959 val |= SCALING_MODE_SEL(2);
1960 I915_WRITE(CNL_PORT_TX_DW5_GRP(port), val);
1961
1962 /* Program PORT_TX_DW2 */
1963 val = I915_READ(CNL_PORT_TX_DW2_LN0(port));
1964 val &= ~(SWING_SEL_LOWER_MASK | SWING_SEL_UPPER_MASK |
1965 RCOMP_SCALAR_MASK);
1966 val |= SWING_SEL_UPPER(ddi_translations[level].dw2_swing_sel);
1967 val |= SWING_SEL_LOWER(ddi_translations[level].dw2_swing_sel);
1968 /* Rcomp scalar is fixed as 0x98 for every table entry */
1969 val |= RCOMP_SCALAR(0x98);
1970 I915_WRITE(CNL_PORT_TX_DW2_GRP(port), val);
1971
1972 /* Program PORT_TX_DW4 */
1973 /* We cannot write to GRP. It would overrite individual loadgen */
1974 for (ln = 0; ln < 4; ln++) {
1975 val = I915_READ(CNL_PORT_TX_DW4_LN(port, ln));
1976 val &= ~(POST_CURSOR_1_MASK | POST_CURSOR_2_MASK |
1977 CURSOR_COEFF_MASK);
1978 val |= POST_CURSOR_1(ddi_translations[level].dw4_post_cursor_1);
1979 val |= POST_CURSOR_2(ddi_translations[level].dw4_post_cursor_2);
1980 val |= CURSOR_COEFF(ddi_translations[level].dw4_cursor_coeff);
1981 I915_WRITE(CNL_PORT_TX_DW4_LN(port, ln), val);
1982 }
1983
1984 /* Program PORT_TX_DW5 */
1985 /* All DW5 values are fixed for every table entry */
1986 val = I915_READ(CNL_PORT_TX_DW5_LN0(port));
1987 val &= ~RTERM_SELECT_MASK;
1988 val |= RTERM_SELECT(6);
1989 val |= TAP3_DISABLE;
1990 I915_WRITE(CNL_PORT_TX_DW5_GRP(port), val);
1991
1992 /* Program PORT_TX_DW7 */
1993 val = I915_READ(CNL_PORT_TX_DW7_LN0(port));
1994 val &= ~N_SCALAR_MASK;
1995 val |= N_SCALAR(ddi_translations[level].dw7_n_scalar);
1996 I915_WRITE(CNL_PORT_TX_DW7_GRP(port), val);
1997}
1998
1999static void cnl_ddi_vswing_sequence(struct intel_encoder *encoder,
2000 int level, enum intel_output_type type)
2001{
2002 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2003 enum port port = encoder->port;
2004 int width, rate, ln;
2005 u32 val;
2006
2007 if (type == INTEL_OUTPUT_HDMI) {
2008 width = 4;
2009 rate = 0; /* Rate is always < than 6GHz for HDMI */
2010 } else {
2011 struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
2012
2013 width = intel_dp->lane_count;
2014 rate = intel_dp->link_rate;
2015 }
2016
2017 /*
2018 * 1. If port type is eDP or DP,
2019 * set PORT_PCS_DW1 cmnkeeper_enable to 1b,
2020 * else clear to 0b.
2021 */
2022 val = I915_READ(CNL_PORT_PCS_DW1_LN0(port));
2023 if (type != INTEL_OUTPUT_HDMI)
2024 val |= COMMON_KEEPER_EN;
2025 else
2026 val &= ~COMMON_KEEPER_EN;
2027 I915_WRITE(CNL_PORT_PCS_DW1_GRP(port), val);
2028
2029 /* 2. Program loadgen select */
2030 /*
2031 * Program PORT_TX_DW4_LN depending on Bit rate and used lanes
2032 * <= 6 GHz and 4 lanes (LN0=0, LN1=1, LN2=1, LN3=1)
2033 * <= 6 GHz and 1,2 lanes (LN0=0, LN1=1, LN2=1, LN3=0)
2034 * > 6 GHz (LN0=0, LN1=0, LN2=0, LN3=0)
2035 */
2036 for (ln = 0; ln <= 3; ln++) {
2037 val = I915_READ(CNL_PORT_TX_DW4_LN(port, ln));
2038 val &= ~LOADGEN_SELECT;
2039
2040 if ((rate <= 600000 && width == 4 && ln >= 1) ||
2041 (rate <= 600000 && width < 4 && (ln == 1 || ln == 2))) {
2042 val |= LOADGEN_SELECT;
2043 }
2044 I915_WRITE(CNL_PORT_TX_DW4_LN(port, ln), val);
2045 }
2046
2047 /* 3. Set PORT_CL_DW5 SUS Clock Config to 11b */
2048 val = I915_READ(CNL_PORT_CL1CM_DW5);
2049 val |= SUS_CLOCK_CONFIG;
2050 I915_WRITE(CNL_PORT_CL1CM_DW5, val);
2051
2052 /* 4. Clear training enable to change swing values */
2053 val = I915_READ(CNL_PORT_TX_DW5_LN0(port));
2054 val &= ~TX_TRAINING_EN;
2055 I915_WRITE(CNL_PORT_TX_DW5_GRP(port), val);
2056
2057 /* 5. Program swing and de-emphasis */
2058 cnl_ddi_vswing_program(encoder, level, type);
2059
2060 /* 6. Set training enable to trigger update */
2061 val = I915_READ(CNL_PORT_TX_DW5_LN0(port));
2062 val |= TX_TRAINING_EN;
2063 I915_WRITE(CNL_PORT_TX_DW5_GRP(port), val);
2064}
2065
2066static uint32_t translate_signal_level(int signal_levels)
2067{
2068 int i;
2069
2070 for (i = 0; i < ARRAY_SIZE(index_to_dp_signal_levels); i++) {
2071 if (index_to_dp_signal_levels[i] == signal_levels)
2072 return i;
2073 }
2074
2075 WARN(1, "Unsupported voltage swing/pre-emphasis level: 0x%x\n",
2076 signal_levels);
2077
2078 return 0;
2079}
2080
2081static uint32_t intel_ddi_dp_level(struct intel_dp *intel_dp)
2082{
2083 uint8_t train_set = intel_dp->train_set[0];
2084 int signal_levels = train_set & (DP_TRAIN_VOLTAGE_SWING_MASK |
2085 DP_TRAIN_PRE_EMPHASIS_MASK);
2086
2087 return translate_signal_level(signal_levels);
2088}
2089
2090u32 bxt_signal_levels(struct intel_dp *intel_dp)
2091{
2092 struct intel_digital_port *dport = dp_to_dig_port(intel_dp);
2093 struct drm_i915_private *dev_priv = to_i915(dport->base.base.dev);
2094 struct intel_encoder *encoder = &dport->base;
2095 int level = intel_ddi_dp_level(intel_dp);
2096
2097 if (IS_CANNONLAKE(dev_priv))
2098 cnl_ddi_vswing_sequence(encoder, level, encoder->type);
2099 else
2100 bxt_ddi_vswing_sequence(encoder, level, encoder->type);
2101
2102 return 0;
2103}
2104
2105uint32_t ddi_signal_levels(struct intel_dp *intel_dp)
2106{
2107 struct intel_digital_port *dport = dp_to_dig_port(intel_dp);
2108 struct drm_i915_private *dev_priv = to_i915(dport->base.base.dev);
2109 struct intel_encoder *encoder = &dport->base;
2110 int level = intel_ddi_dp_level(intel_dp);
2111
2112 if (IS_GEN9_BC(dev_priv))
2113 skl_ddi_set_iboost(encoder, level, encoder->type);
2114
2115 return DDI_BUF_TRANS_SELECT(level);
2116}
2117
2118static void intel_ddi_clk_select(struct intel_encoder *encoder,
2119 const struct intel_shared_dpll *pll)
2120{
2121 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2122 enum port port = encoder->port;
2123 uint32_t val;
2124
2125 if (WARN_ON(!pll))
2126 return;
2127
2128 mutex_lock(&dev_priv->dpll_lock);
2129
2130 if (IS_CANNONLAKE(dev_priv)) {
2131 /* Configure DPCLKA_CFGCR0 to map the DPLL to the DDI. */
2132 val = I915_READ(DPCLKA_CFGCR0);
2133 val &= ~DPCLKA_CFGCR0_DDI_CLK_SEL_MASK(port);
2134 val |= DPCLKA_CFGCR0_DDI_CLK_SEL(pll->id, port);
2135 I915_WRITE(DPCLKA_CFGCR0, val);
2136
2137 /*
2138 * Configure DPCLKA_CFGCR0 to turn on the clock for the DDI.
2139 * This step and the step before must be done with separate
2140 * register writes.
2141 */
2142 val = I915_READ(DPCLKA_CFGCR0);
2143 val &= ~DPCLKA_CFGCR0_DDI_CLK_OFF(port);
2144 I915_WRITE(DPCLKA_CFGCR0, val);
2145 } else if (IS_GEN9_BC(dev_priv)) {
2146 /* DDI -> PLL mapping */
2147 val = I915_READ(DPLL_CTRL2);
2148
2149 val &= ~(DPLL_CTRL2_DDI_CLK_OFF(port) |
2150 DPLL_CTRL2_DDI_CLK_SEL_MASK(port));
2151 val |= (DPLL_CTRL2_DDI_CLK_SEL(pll->id, port) |
2152 DPLL_CTRL2_DDI_SEL_OVERRIDE(port));
2153
2154 I915_WRITE(DPLL_CTRL2, val);
2155
2156 } else if (INTEL_GEN(dev_priv) < 9) {
2157 I915_WRITE(PORT_CLK_SEL(port), hsw_pll_to_ddi_pll_sel(pll));
2158 }
2159
2160 mutex_unlock(&dev_priv->dpll_lock);
2161}
2162
2163static void intel_ddi_clk_disable(struct intel_encoder *encoder)
2164{
2165 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2166 enum port port = encoder->port;
2167
2168 if (IS_CANNONLAKE(dev_priv))
2169 I915_WRITE(DPCLKA_CFGCR0, I915_READ(DPCLKA_CFGCR0) |
2170 DPCLKA_CFGCR0_DDI_CLK_OFF(port));
2171 else if (IS_GEN9_BC(dev_priv))
2172 I915_WRITE(DPLL_CTRL2, I915_READ(DPLL_CTRL2) |
2173 DPLL_CTRL2_DDI_CLK_OFF(port));
2174 else if (INTEL_GEN(dev_priv) < 9)
2175 I915_WRITE(PORT_CLK_SEL(port), PORT_CLK_SEL_NONE);
2176}
2177
2178static void intel_ddi_pre_enable_dp(struct intel_encoder *encoder,
2179 const struct intel_crtc_state *crtc_state,
2180 const struct drm_connector_state *conn_state)
2181{
2182 struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
2183 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2184 enum port port = encoder->port;
2185 struct intel_digital_port *dig_port = enc_to_dig_port(&encoder->base);
2186 bool is_mst = intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST);
2187 int level = intel_ddi_dp_level(intel_dp);
2188
2189 WARN_ON(is_mst && (port == PORT_A || port == PORT_E));
2190
2191 intel_dp_set_link_params(intel_dp, crtc_state->port_clock,
2192 crtc_state->lane_count, is_mst);
2193
2194 intel_edp_panel_on(intel_dp);
2195
2196 intel_ddi_clk_select(encoder, crtc_state->shared_dpll);
2197
2198 intel_display_power_get(dev_priv, dig_port->ddi_io_power_domain);
2199
2200 if (IS_CANNONLAKE(dev_priv))
2201 cnl_ddi_vswing_sequence(encoder, level, encoder->type);
2202 else if (IS_GEN9_LP(dev_priv))
2203 bxt_ddi_vswing_sequence(encoder, level, encoder->type);
2204 else
2205 intel_prepare_dp_ddi_buffers(encoder, crtc_state);
2206
2207 intel_ddi_init_dp_buf_reg(encoder);
2208 intel_dp_sink_dpms(intel_dp, DRM_MODE_DPMS_ON);
2209 intel_dp_start_link_train(intel_dp);
2210 if (port != PORT_A || INTEL_GEN(dev_priv) >= 9)
2211 intel_dp_stop_link_train(intel_dp);
2212}
2213
2214static void intel_ddi_pre_enable_hdmi(struct intel_encoder *encoder,
2215 const struct intel_crtc_state *crtc_state,
2216 const struct drm_connector_state *conn_state)
2217{
2218 struct intel_digital_port *intel_dig_port = enc_to_dig_port(&encoder->base);
2219 struct intel_hdmi *intel_hdmi = &intel_dig_port->hdmi;
2220 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2221 enum port port = encoder->port;
2222 int level = intel_ddi_hdmi_level(dev_priv, port);
2223 struct intel_digital_port *dig_port = enc_to_dig_port(&encoder->base);
2224
2225 intel_dp_dual_mode_set_tmds_output(intel_hdmi, true);
2226 intel_ddi_clk_select(encoder, crtc_state->shared_dpll);
2227
2228 intel_display_power_get(dev_priv, dig_port->ddi_io_power_domain);
2229
2230 if (IS_CANNONLAKE(dev_priv))
2231 cnl_ddi_vswing_sequence(encoder, level, INTEL_OUTPUT_HDMI);
2232 else if (IS_GEN9_LP(dev_priv))
2233 bxt_ddi_vswing_sequence(encoder, level, INTEL_OUTPUT_HDMI);
2234 else
2235 intel_prepare_hdmi_ddi_buffers(encoder, level);
2236
2237 if (IS_GEN9_BC(dev_priv))
2238 skl_ddi_set_iboost(encoder, level, INTEL_OUTPUT_HDMI);
2239
2240 intel_dig_port->set_infoframes(&encoder->base,
2241 crtc_state->has_infoframe,
2242 crtc_state, conn_state);
2243}
2244
2245static void intel_ddi_pre_enable(struct intel_encoder *encoder,
2246 const struct intel_crtc_state *crtc_state,
2247 const struct drm_connector_state *conn_state)
2248{
2249 struct intel_crtc *crtc = to_intel_crtc(crtc_state->base.crtc);
2250 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
2251 enum pipe pipe = crtc->pipe;
2252
2253 /*
2254 * When called from DP MST code:
2255 * - conn_state will be NULL
2256 * - encoder will be the main encoder (ie. mst->primary)
2257 * - the main connector associated with this port
2258 * won't be active or linked to a crtc
2259 * - crtc_state will be the state of the first stream to
2260 * be activated on this port, and it may not be the same
2261 * stream that will be deactivated last, but each stream
2262 * should have a state that is identical when it comes to
2263 * the DP link parameteres
2264 */
2265
2266 WARN_ON(crtc_state->has_pch_encoder);
2267
2268 intel_set_cpu_fifo_underrun_reporting(dev_priv, pipe, true);
2269
2270 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI))
2271 intel_ddi_pre_enable_hdmi(encoder, crtc_state, conn_state);
2272 else
2273 intel_ddi_pre_enable_dp(encoder, crtc_state, conn_state);
2274}
2275
2276static void intel_disable_ddi_buf(struct intel_encoder *encoder)
2277{
2278 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2279 enum port port = encoder->port;
2280 bool wait = false;
2281 u32 val;
2282
2283 val = I915_READ(DDI_BUF_CTL(port));
2284 if (val & DDI_BUF_CTL_ENABLE) {
2285 val &= ~DDI_BUF_CTL_ENABLE;
2286 I915_WRITE(DDI_BUF_CTL(port), val);
2287 wait = true;
2288 }
2289
2290 val = I915_READ(DP_TP_CTL(port));
2291 val &= ~(DP_TP_CTL_ENABLE | DP_TP_CTL_LINK_TRAIN_MASK);
2292 val |= DP_TP_CTL_LINK_TRAIN_PAT1;
2293 I915_WRITE(DP_TP_CTL(port), val);
2294
2295 if (wait)
2296 intel_wait_ddi_buf_idle(dev_priv, port);
2297}
2298
2299static void intel_ddi_post_disable_dp(struct intel_encoder *encoder,
2300 const struct intel_crtc_state *old_crtc_state,
2301 const struct drm_connector_state *old_conn_state)
2302{
2303 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2304 struct intel_digital_port *dig_port = enc_to_dig_port(&encoder->base);
2305 struct intel_dp *intel_dp = &dig_port->dp;
2306
2307 /*
2308 * Power down sink before disabling the port, otherwise we end
2309 * up getting interrupts from the sink on detecting link loss.
2310 */
2311 intel_dp_sink_dpms(intel_dp, DRM_MODE_DPMS_OFF);
2312
2313 intel_disable_ddi_buf(encoder);
2314
2315 intel_edp_panel_vdd_on(intel_dp);
2316 intel_edp_panel_off(intel_dp);
2317
2318 intel_display_power_put(dev_priv, dig_port->ddi_io_power_domain);
2319
2320 intel_ddi_clk_disable(encoder);
2321}
2322
2323static void intel_ddi_post_disable_hdmi(struct intel_encoder *encoder,
2324 const struct intel_crtc_state *old_crtc_state,
2325 const struct drm_connector_state *old_conn_state)
2326{
2327 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2328 struct intel_digital_port *dig_port = enc_to_dig_port(&encoder->base);
2329 struct intel_hdmi *intel_hdmi = &dig_port->hdmi;
2330
2331 intel_disable_ddi_buf(encoder);
2332
2333 dig_port->set_infoframes(&encoder->base, false,
2334 old_crtc_state, old_conn_state);
2335
2336 intel_display_power_put(dev_priv, dig_port->ddi_io_power_domain);
2337
2338 intel_ddi_clk_disable(encoder);
2339
2340 intel_dp_dual_mode_set_tmds_output(intel_hdmi, false);
2341}
2342
2343static void intel_ddi_post_disable(struct intel_encoder *encoder,
2344 const struct intel_crtc_state *old_crtc_state,
2345 const struct drm_connector_state *old_conn_state)
2346{
2347 /*
2348 * When called from DP MST code:
2349 * - old_conn_state will be NULL
2350 * - encoder will be the main encoder (ie. mst->primary)
2351 * - the main connector associated with this port
2352 * won't be active or linked to a crtc
2353 * - old_crtc_state will be the state of the last stream to
2354 * be deactivated on this port, and it may not be the same
2355 * stream that was activated last, but each stream
2356 * should have a state that is identical when it comes to
2357 * the DP link parameteres
2358 */
2359
2360 if (intel_crtc_has_type(old_crtc_state, INTEL_OUTPUT_HDMI))
2361 intel_ddi_post_disable_hdmi(encoder,
2362 old_crtc_state, old_conn_state);
2363 else
2364 intel_ddi_post_disable_dp(encoder,
2365 old_crtc_state, old_conn_state);
2366}
2367
2368void intel_ddi_fdi_post_disable(struct intel_encoder *encoder,
2369 const struct intel_crtc_state *old_crtc_state,
2370 const struct drm_connector_state *old_conn_state)
2371{
2372 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2373 uint32_t val;
2374
2375 /*
2376 * Bspec lists this as both step 13 (before DDI_BUF_CTL disable)
2377 * and step 18 (after clearing PORT_CLK_SEL). Based on a BUN,
2378 * step 13 is the correct place for it. Step 18 is where it was
2379 * originally before the BUN.
2380 */
2381 val = I915_READ(FDI_RX_CTL(PIPE_A));
2382 val &= ~FDI_RX_ENABLE;
2383 I915_WRITE(FDI_RX_CTL(PIPE_A), val);
2384
2385 intel_disable_ddi_buf(encoder);
2386 intel_ddi_clk_disable(encoder);
2387
2388 val = I915_READ(FDI_RX_MISC(PIPE_A));
2389 val &= ~(FDI_RX_PWRDN_LANE1_MASK | FDI_RX_PWRDN_LANE0_MASK);
2390 val |= FDI_RX_PWRDN_LANE1_VAL(2) | FDI_RX_PWRDN_LANE0_VAL(2);
2391 I915_WRITE(FDI_RX_MISC(PIPE_A), val);
2392
2393 val = I915_READ(FDI_RX_CTL(PIPE_A));
2394 val &= ~FDI_PCDCLK;
2395 I915_WRITE(FDI_RX_CTL(PIPE_A), val);
2396
2397 val = I915_READ(FDI_RX_CTL(PIPE_A));
2398 val &= ~FDI_RX_PLL_ENABLE;
2399 I915_WRITE(FDI_RX_CTL(PIPE_A), val);
2400}
2401
2402static void intel_enable_ddi_dp(struct intel_encoder *encoder,
2403 const struct intel_crtc_state *crtc_state,
2404 const struct drm_connector_state *conn_state)
2405{
2406 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2407 struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
2408 enum port port = encoder->port;
2409
2410 if (port == PORT_A && INTEL_GEN(dev_priv) < 9)
2411 intel_dp_stop_link_train(intel_dp);
2412
2413 intel_edp_backlight_on(crtc_state, conn_state);
2414 intel_psr_enable(intel_dp, crtc_state);
2415 intel_edp_drrs_enable(intel_dp, crtc_state);
2416
2417 if (crtc_state->has_audio)
2418 intel_audio_codec_enable(encoder, crtc_state, conn_state);
2419}
2420
2421static void intel_enable_ddi_hdmi(struct intel_encoder *encoder,
2422 const struct intel_crtc_state *crtc_state,
2423 const struct drm_connector_state *conn_state)
2424{
2425 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2426 struct intel_digital_port *dig_port = enc_to_dig_port(&encoder->base);
2427 enum port port = encoder->port;
2428
2429 intel_hdmi_handle_sink_scrambling(encoder,
2430 conn_state->connector,
2431 crtc_state->hdmi_high_tmds_clock_ratio,
2432 crtc_state->hdmi_scrambling);
2433
2434 /* Display WA #1143: skl,kbl,cfl */
2435 if (IS_GEN9_BC(dev_priv)) {
2436 /*
2437 * For some reason these chicken bits have been
2438 * stuffed into a transcoder register, event though
2439 * the bits affect a specific DDI port rather than
2440 * a specific transcoder.
2441 */
2442 static const enum transcoder port_to_transcoder[] = {
2443 [PORT_A] = TRANSCODER_EDP,
2444 [PORT_B] = TRANSCODER_A,
2445 [PORT_C] = TRANSCODER_B,
2446 [PORT_D] = TRANSCODER_C,
2447 [PORT_E] = TRANSCODER_A,
2448 };
2449 enum transcoder transcoder = port_to_transcoder[port];
2450 u32 val;
2451
2452 val = I915_READ(CHICKEN_TRANS(transcoder));
2453
2454 if (port == PORT_E)
2455 val |= DDIE_TRAINING_OVERRIDE_ENABLE |
2456 DDIE_TRAINING_OVERRIDE_VALUE;
2457 else
2458 val |= DDI_TRAINING_OVERRIDE_ENABLE |
2459 DDI_TRAINING_OVERRIDE_VALUE;
2460
2461 I915_WRITE(CHICKEN_TRANS(transcoder), val);
2462 POSTING_READ(CHICKEN_TRANS(transcoder));
2463
2464 udelay(1);
2465
2466 if (port == PORT_E)
2467 val &= ~(DDIE_TRAINING_OVERRIDE_ENABLE |
2468 DDIE_TRAINING_OVERRIDE_VALUE);
2469 else
2470 val &= ~(DDI_TRAINING_OVERRIDE_ENABLE |
2471 DDI_TRAINING_OVERRIDE_VALUE);
2472
2473 I915_WRITE(CHICKEN_TRANS(transcoder), val);
2474 }
2475
2476 /* In HDMI/DVI mode, the port width, and swing/emphasis values
2477 * are ignored so nothing special needs to be done besides
2478 * enabling the port.
2479 */
2480 I915_WRITE(DDI_BUF_CTL(port),
2481 dig_port->saved_port_bits | DDI_BUF_CTL_ENABLE);
2482
2483 if (crtc_state->has_audio)
2484 intel_audio_codec_enable(encoder, crtc_state, conn_state);
2485}
2486
2487static void intel_enable_ddi(struct intel_encoder *encoder,
2488 const struct intel_crtc_state *crtc_state,
2489 const struct drm_connector_state *conn_state)
2490{
2491 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI))
2492 intel_enable_ddi_hdmi(encoder, crtc_state, conn_state);
2493 else
2494 intel_enable_ddi_dp(encoder, crtc_state, conn_state);
2495
2496 /* Enable hdcp if it's desired */
2497 if (conn_state->content_protection ==
2498 DRM_MODE_CONTENT_PROTECTION_DESIRED)
2499 intel_hdcp_enable(to_intel_connector(conn_state->connector));
2500}
2501
2502static void intel_disable_ddi_dp(struct intel_encoder *encoder,
2503 const struct intel_crtc_state *old_crtc_state,
2504 const struct drm_connector_state *old_conn_state)
2505{
2506 struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
2507
2508 intel_dp->link_trained = false;
2509
2510 if (old_crtc_state->has_audio)
2511 intel_audio_codec_disable(encoder,
2512 old_crtc_state, old_conn_state);
2513
2514 intel_edp_drrs_disable(intel_dp, old_crtc_state);
2515 intel_psr_disable(intel_dp, old_crtc_state);
2516 intel_edp_backlight_off(old_conn_state);
2517}
2518
2519static void intel_disable_ddi_hdmi(struct intel_encoder *encoder,
2520 const struct intel_crtc_state *old_crtc_state,
2521 const struct drm_connector_state *old_conn_state)
2522{
2523 if (old_crtc_state->has_audio)
2524 intel_audio_codec_disable(encoder,
2525 old_crtc_state, old_conn_state);
2526
2527 intel_hdmi_handle_sink_scrambling(encoder,
2528 old_conn_state->connector,
2529 false, false);
2530}
2531
2532static void intel_disable_ddi(struct intel_encoder *encoder,
2533 const struct intel_crtc_state *old_crtc_state,
2534 const struct drm_connector_state *old_conn_state)
2535{
2536 intel_hdcp_disable(to_intel_connector(old_conn_state->connector));
2537
2538 if (intel_crtc_has_type(old_crtc_state, INTEL_OUTPUT_HDMI))
2539 intel_disable_ddi_hdmi(encoder, old_crtc_state, old_conn_state);
2540 else
2541 intel_disable_ddi_dp(encoder, old_crtc_state, old_conn_state);
2542}
2543
2544static void bxt_ddi_pre_pll_enable(struct intel_encoder *encoder,
2545 const struct intel_crtc_state *pipe_config,
2546 const struct drm_connector_state *conn_state)
2547{
2548 uint8_t mask = pipe_config->lane_lat_optim_mask;
2549
2550 bxt_ddi_phy_set_lane_optim_mask(encoder, mask);
2551}
2552
2553void intel_ddi_prepare_link_retrain(struct intel_dp *intel_dp)
2554{
2555 struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
2556 struct drm_i915_private *dev_priv =
2557 to_i915(intel_dig_port->base.base.dev);
2558 enum port port = intel_dig_port->base.port;
2559 uint32_t val;
2560 bool wait = false;
2561
2562 if (I915_READ(DP_TP_CTL(port)) & DP_TP_CTL_ENABLE) {
2563 val = I915_READ(DDI_BUF_CTL(port));
2564 if (val & DDI_BUF_CTL_ENABLE) {
2565 val &= ~DDI_BUF_CTL_ENABLE;
2566 I915_WRITE(DDI_BUF_CTL(port), val);
2567 wait = true;
2568 }
2569
2570 val = I915_READ(DP_TP_CTL(port));
2571 val &= ~(DP_TP_CTL_ENABLE | DP_TP_CTL_LINK_TRAIN_MASK);
2572 val |= DP_TP_CTL_LINK_TRAIN_PAT1;
2573 I915_WRITE(DP_TP_CTL(port), val);
2574 POSTING_READ(DP_TP_CTL(port));
2575
2576 if (wait)
2577 intel_wait_ddi_buf_idle(dev_priv, port);
2578 }
2579
2580 val = DP_TP_CTL_ENABLE |
2581 DP_TP_CTL_LINK_TRAIN_PAT1 | DP_TP_CTL_SCRAMBLE_DISABLE;
2582 if (intel_dp->link_mst)
2583 val |= DP_TP_CTL_MODE_MST;
2584 else {
2585 val |= DP_TP_CTL_MODE_SST;
2586 if (drm_dp_enhanced_frame_cap(intel_dp->dpcd))
2587 val |= DP_TP_CTL_ENHANCED_FRAME_ENABLE;
2588 }
2589 I915_WRITE(DP_TP_CTL(port), val);
2590 POSTING_READ(DP_TP_CTL(port));
2591
2592 intel_dp->DP |= DDI_BUF_CTL_ENABLE;
2593 I915_WRITE(DDI_BUF_CTL(port), intel_dp->DP);
2594 POSTING_READ(DDI_BUF_CTL(port));
2595
2596 udelay(600);
2597}
2598
2599static bool intel_ddi_is_audio_enabled(struct drm_i915_private *dev_priv,
2600 enum transcoder cpu_transcoder)
2601{
2602 if (cpu_transcoder == TRANSCODER_EDP)
2603 return false;
2604
2605 if (!intel_display_power_is_enabled(dev_priv, POWER_DOMAIN_AUDIO))
2606 return false;
2607
2608 return I915_READ(HSW_AUD_PIN_ELD_CP_VLD) &
2609 AUDIO_OUTPUT_ENABLE(cpu_transcoder);
2610}
2611
2612void intel_ddi_compute_min_voltage_level(struct drm_i915_private *dev_priv,
2613 struct intel_crtc_state *crtc_state)
2614{
2615 if (IS_CANNONLAKE(dev_priv) && crtc_state->port_clock > 594000)
2616 crtc_state->min_voltage_level = 2;
2617}
2618
2619void intel_ddi_get_config(struct intel_encoder *encoder,
2620 struct intel_crtc_state *pipe_config)
2621{
2622 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2623 struct intel_crtc *intel_crtc = to_intel_crtc(pipe_config->base.crtc);
2624 enum transcoder cpu_transcoder = pipe_config->cpu_transcoder;
2625 struct intel_digital_port *intel_dig_port;
2626 u32 temp, flags = 0;
2627
2628 /* XXX: DSI transcoder paranoia */
2629 if (WARN_ON(transcoder_is_dsi(cpu_transcoder)))
2630 return;
2631
2632 temp = I915_READ(TRANS_DDI_FUNC_CTL(cpu_transcoder));
2633 if (temp & TRANS_DDI_PHSYNC)
2634 flags |= DRM_MODE_FLAG_PHSYNC;
2635 else
2636 flags |= DRM_MODE_FLAG_NHSYNC;
2637 if (temp & TRANS_DDI_PVSYNC)
2638 flags |= DRM_MODE_FLAG_PVSYNC;
2639 else
2640 flags |= DRM_MODE_FLAG_NVSYNC;
2641
2642 pipe_config->base.adjusted_mode.flags |= flags;
2643
2644 switch (temp & TRANS_DDI_BPC_MASK) {
2645 case TRANS_DDI_BPC_6:
2646 pipe_config->pipe_bpp = 18;
2647 break;
2648 case TRANS_DDI_BPC_8:
2649 pipe_config->pipe_bpp = 24;
2650 break;
2651 case TRANS_DDI_BPC_10:
2652 pipe_config->pipe_bpp = 30;
2653 break;
2654 case TRANS_DDI_BPC_12:
2655 pipe_config->pipe_bpp = 36;
2656 break;
2657 default:
2658 break;
2659 }
2660
2661 switch (temp & TRANS_DDI_MODE_SELECT_MASK) {
2662 case TRANS_DDI_MODE_SELECT_HDMI:
2663 pipe_config->has_hdmi_sink = true;
2664 intel_dig_port = enc_to_dig_port(&encoder->base);
2665
2666 if (intel_dig_port->infoframe_enabled(&encoder->base, pipe_config))
2667 pipe_config->has_infoframe = true;
2668
2669 if ((temp & TRANS_DDI_HDMI_SCRAMBLING_MASK) ==
2670 TRANS_DDI_HDMI_SCRAMBLING_MASK)
2671 pipe_config->hdmi_scrambling = true;
2672 if (temp & TRANS_DDI_HIGH_TMDS_CHAR_RATE)
2673 pipe_config->hdmi_high_tmds_clock_ratio = true;
2674 /* fall through */
2675 case TRANS_DDI_MODE_SELECT_DVI:
2676 pipe_config->output_types |= BIT(INTEL_OUTPUT_HDMI);
2677 pipe_config->lane_count = 4;
2678 break;
2679 case TRANS_DDI_MODE_SELECT_FDI:
2680 pipe_config->output_types |= BIT(INTEL_OUTPUT_ANALOG);
2681 break;
2682 case TRANS_DDI_MODE_SELECT_DP_SST:
2683 if (encoder->type == INTEL_OUTPUT_EDP)
2684 pipe_config->output_types |= BIT(INTEL_OUTPUT_EDP);
2685 else
2686 pipe_config->output_types |= BIT(INTEL_OUTPUT_DP);
2687 pipe_config->lane_count =
2688 ((temp & DDI_PORT_WIDTH_MASK) >> DDI_PORT_WIDTH_SHIFT) + 1;
2689 intel_dp_get_m_n(intel_crtc, pipe_config);
2690 break;
2691 case TRANS_DDI_MODE_SELECT_DP_MST:
2692 pipe_config->output_types |= BIT(INTEL_OUTPUT_DP_MST);
2693 pipe_config->lane_count =
2694 ((temp & DDI_PORT_WIDTH_MASK) >> DDI_PORT_WIDTH_SHIFT) + 1;
2695 intel_dp_get_m_n(intel_crtc, pipe_config);
2696 break;
2697 default:
2698 break;
2699 }
2700
2701 pipe_config->has_audio =
2702 intel_ddi_is_audio_enabled(dev_priv, cpu_transcoder);
2703
2704 if (encoder->type == INTEL_OUTPUT_EDP && dev_priv->vbt.edp.bpp &&
2705 pipe_config->pipe_bpp > dev_priv->vbt.edp.bpp) {
2706 /*
2707 * This is a big fat ugly hack.
2708 *
2709 * Some machines in UEFI boot mode provide us a VBT that has 18
2710 * bpp and 1.62 GHz link bandwidth for eDP, which for reasons
2711 * unknown we fail to light up. Yet the same BIOS boots up with
2712 * 24 bpp and 2.7 GHz link. Use the same bpp as the BIOS uses as
2713 * max, not what it tells us to use.
2714 *
2715 * Note: This will still be broken if the eDP panel is not lit
2716 * up by the BIOS, and thus we can't get the mode at module
2717 * load.
2718 */
2719 DRM_DEBUG_KMS("pipe has %d bpp for eDP panel, overriding BIOS-provided max %d bpp\n",
2720 pipe_config->pipe_bpp, dev_priv->vbt.edp.bpp);
2721 dev_priv->vbt.edp.bpp = pipe_config->pipe_bpp;
2722 }
2723
2724 intel_ddi_clock_get(encoder, pipe_config);
2725
2726 if (IS_GEN9_LP(dev_priv))
2727 pipe_config->lane_lat_optim_mask =
2728 bxt_ddi_phy_get_lane_lat_optim_mask(encoder);
2729
2730 intel_ddi_compute_min_voltage_level(dev_priv, pipe_config);
2731}
2732
2733static enum intel_output_type
2734intel_ddi_compute_output_type(struct intel_encoder *encoder,
2735 struct intel_crtc_state *crtc_state,
2736 struct drm_connector_state *conn_state)
2737{
2738 switch (conn_state->connector->connector_type) {
2739 case DRM_MODE_CONNECTOR_HDMIA:
2740 return INTEL_OUTPUT_HDMI;
2741 case DRM_MODE_CONNECTOR_eDP:
2742 return INTEL_OUTPUT_EDP;
2743 case DRM_MODE_CONNECTOR_DisplayPort:
2744 return INTEL_OUTPUT_DP;
2745 default:
2746 MISSING_CASE(conn_state->connector->connector_type);
2747 return INTEL_OUTPUT_UNUSED;
2748 }
2749}
2750
2751static bool intel_ddi_compute_config(struct intel_encoder *encoder,
2752 struct intel_crtc_state *pipe_config,
2753 struct drm_connector_state *conn_state)
2754{
2755 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2756 enum port port = encoder->port;
2757 int ret;
2758
2759 if (port == PORT_A)
2760 pipe_config->cpu_transcoder = TRANSCODER_EDP;
2761
2762 if (intel_crtc_has_type(pipe_config, INTEL_OUTPUT_HDMI))
2763 ret = intel_hdmi_compute_config(encoder, pipe_config, conn_state);
2764 else
2765 ret = intel_dp_compute_config(encoder, pipe_config, conn_state);
2766
2767 if (IS_GEN9_LP(dev_priv) && ret)
2768 pipe_config->lane_lat_optim_mask =
2769 bxt_ddi_phy_calc_lane_lat_optim_mask(pipe_config->lane_count);
2770
2771 intel_ddi_compute_min_voltage_level(dev_priv, pipe_config);
2772
2773 return ret;
2774
2775}
2776
2777static const struct drm_encoder_funcs intel_ddi_funcs = {
2778 .reset = intel_dp_encoder_reset,
2779 .destroy = intel_dp_encoder_destroy,
2780};
2781
2782static struct intel_connector *
2783intel_ddi_init_dp_connector(struct intel_digital_port *intel_dig_port)
2784{
2785 struct intel_connector *connector;
2786 enum port port = intel_dig_port->base.port;
2787
2788 connector = intel_connector_alloc();
2789 if (!connector)
2790 return NULL;
2791
2792 intel_dig_port->dp.output_reg = DDI_BUF_CTL(port);
2793 if (!intel_dp_init_connector(intel_dig_port, connector)) {
2794 kfree(connector);
2795 return NULL;
2796 }
2797
2798 return connector;
2799}
2800
2801static int modeset_pipe(struct drm_crtc *crtc,
2802 struct drm_modeset_acquire_ctx *ctx)
2803{
2804 struct drm_atomic_state *state;
2805 struct drm_crtc_state *crtc_state;
2806 int ret;
2807
2808 state = drm_atomic_state_alloc(crtc->dev);
2809 if (!state)
2810 return -ENOMEM;
2811
2812 state->acquire_ctx = ctx;
2813
2814 crtc_state = drm_atomic_get_crtc_state(state, crtc);
2815 if (IS_ERR(crtc_state)) {
2816 ret = PTR_ERR(crtc_state);
2817 goto out;
2818 }
2819
2820 crtc_state->mode_changed = true;
2821
2822 ret = drm_atomic_add_affected_connectors(state, crtc);
2823 if (ret)
2824 goto out;
2825
2826 ret = drm_atomic_add_affected_planes(state, crtc);
2827 if (ret)
2828 goto out;
2829
2830 ret = drm_atomic_commit(state);
2831 if (ret)
2832 goto out;
2833
2834 return 0;
2835
2836 out:
2837 drm_atomic_state_put(state);
2838
2839 return ret;
2840}
2841
2842static int intel_hdmi_reset_link(struct intel_encoder *encoder,
2843 struct drm_modeset_acquire_ctx *ctx)
2844{
2845 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2846 struct intel_hdmi *hdmi = enc_to_intel_hdmi(&encoder->base);
2847 struct intel_connector *connector = hdmi->attached_connector;
2848 struct i2c_adapter *adapter =
2849 intel_gmbus_get_adapter(dev_priv, hdmi->ddc_bus);
2850 struct drm_connector_state *conn_state;
2851 struct intel_crtc_state *crtc_state;
2852 struct intel_crtc *crtc;
2853 u8 config;
2854 int ret;
2855
2856 if (!connector || connector->base.status != connector_status_connected)
2857 return 0;
2858
2859 ret = drm_modeset_lock(&dev_priv->drm.mode_config.connection_mutex,
2860 ctx);
2861 if (ret)
2862 return ret;
2863
2864 conn_state = connector->base.state;
2865
2866 crtc = to_intel_crtc(conn_state->crtc);
2867 if (!crtc)
2868 return 0;
2869
2870 ret = drm_modeset_lock(&crtc->base.mutex, ctx);
2871 if (ret)
2872 return ret;
2873
2874 crtc_state = to_intel_crtc_state(crtc->base.state);
2875
2876 WARN_ON(!intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI));
2877
2878 if (!crtc_state->base.active)
2879 return 0;
2880
2881 if (!crtc_state->hdmi_high_tmds_clock_ratio &&
2882 !crtc_state->hdmi_scrambling)
2883 return 0;
2884
2885 if (conn_state->commit &&
2886 !try_wait_for_completion(&conn_state->commit->hw_done))
2887 return 0;
2888
2889 ret = drm_scdc_readb(adapter, SCDC_TMDS_CONFIG, &config);
2890 if (ret < 0) {
2891 DRM_ERROR("Failed to read TMDS config: %d\n", ret);
2892 return 0;
2893 }
2894
2895 if (!!(config & SCDC_TMDS_BIT_CLOCK_RATIO_BY_40) ==
2896 crtc_state->hdmi_high_tmds_clock_ratio &&
2897 !!(config & SCDC_SCRAMBLING_ENABLE) ==
2898 crtc_state->hdmi_scrambling)
2899 return 0;
2900
2901 /*
2902 * HDMI 2.0 says that one should not send scrambled data
2903 * prior to configuring the sink scrambling, and that
2904 * TMDS clock/data transmission should be suspended when
2905 * changing the TMDS clock rate in the sink. So let's
2906 * just do a full modeset here, even though some sinks
2907 * would be perfectly happy if were to just reconfigure
2908 * the SCDC settings on the fly.
2909 */
2910 return modeset_pipe(&crtc->base, ctx);
2911}
2912
2913static bool intel_ddi_hotplug(struct intel_encoder *encoder,
2914 struct intel_connector *connector)
2915{
2916 struct drm_modeset_acquire_ctx ctx;
2917 bool changed;
2918 int ret;
2919
2920 changed = intel_encoder_hotplug(encoder, connector);
2921
2922 drm_modeset_acquire_init(&ctx, 0);
2923
2924 for (;;) {
2925 if (connector->base.connector_type == DRM_MODE_CONNECTOR_HDMIA)
2926 ret = intel_hdmi_reset_link(encoder, &ctx);
2927 else
2928 ret = intel_dp_retrain_link(encoder, &ctx);
2929
2930 if (ret == -EDEADLK) {
2931 drm_modeset_backoff(&ctx);
2932 continue;
2933 }
2934
2935 break;
2936 }
2937
2938 drm_modeset_drop_locks(&ctx);
2939 drm_modeset_acquire_fini(&ctx);
2940 WARN(ret, "Acquiring modeset locks failed with %i\n", ret);
2941
2942 return changed;
2943}
2944
2945static struct intel_connector *
2946intel_ddi_init_hdmi_connector(struct intel_digital_port *intel_dig_port)
2947{
2948 struct intel_connector *connector;
2949 enum port port = intel_dig_port->base.port;
2950
2951 connector = intel_connector_alloc();
2952 if (!connector)
2953 return NULL;
2954
2955 intel_dig_port->hdmi.hdmi_reg = DDI_BUF_CTL(port);
2956 intel_hdmi_init_connector(intel_dig_port, connector);
2957
2958 return connector;
2959}
2960
2961static bool intel_ddi_a_force_4_lanes(struct intel_digital_port *dport)
2962{
2963 struct drm_i915_private *dev_priv = to_i915(dport->base.base.dev);
2964
2965 if (dport->base.port != PORT_A)
2966 return false;
2967
2968 if (dport->saved_port_bits & DDI_A_4_LANES)
2969 return false;
2970
2971 /* Broxton/Geminilake: Bspec says that DDI_A_4_LANES is the only
2972 * supported configuration
2973 */
2974 if (IS_GEN9_LP(dev_priv))
2975 return true;
2976
2977 /* Cannonlake: Most of SKUs don't support DDI_E, and the only
2978 * one who does also have a full A/E split called
2979 * DDI_F what makes DDI_E useless. However for this
2980 * case let's trust VBT info.
2981 */
2982 if (IS_CANNONLAKE(dev_priv) &&
2983 !intel_bios_is_port_present(dev_priv, PORT_E))
2984 return true;
2985
2986 return false;
2987}
2988
2989static int
2990intel_ddi_max_lanes(struct intel_digital_port *intel_dport)
2991{
2992 struct drm_i915_private *dev_priv = to_i915(intel_dport->base.base.dev);
2993 enum port port = intel_dport->base.port;
2994 int max_lanes = 4;
2995
2996 if (INTEL_GEN(dev_priv) >= 11)
2997 return max_lanes;
2998
2999 if (port == PORT_A || port == PORT_E) {
3000 if (I915_READ(DDI_BUF_CTL(PORT_A)) & DDI_A_4_LANES)
3001 max_lanes = port == PORT_A ? 4 : 0;
3002 else
3003 /* Both A and E share 2 lanes */
3004 max_lanes = 2;
3005 }
3006
3007 /*
3008 * Some BIOS might fail to set this bit on port A if eDP
3009 * wasn't lit up at boot. Force this bit set when needed
3010 * so we use the proper lane count for our calculations.
3011 */
3012 if (intel_ddi_a_force_4_lanes(intel_dport)) {
3013 DRM_DEBUG_KMS("Forcing DDI_A_4_LANES for port A\n");
3014 intel_dport->saved_port_bits |= DDI_A_4_LANES;
3015 max_lanes = 4;
3016 }
3017
3018 return max_lanes;
3019}
3020
3021void intel_ddi_init(struct drm_i915_private *dev_priv, enum port port)
3022{
3023 struct intel_digital_port *intel_dig_port;
3024 struct intel_encoder *intel_encoder;
3025 struct drm_encoder *encoder;
3026 bool init_hdmi, init_dp, init_lspcon = false;
3027
3028
3029 init_hdmi = (dev_priv->vbt.ddi_port_info[port].supports_dvi ||
3030 dev_priv->vbt.ddi_port_info[port].supports_hdmi);
3031 init_dp = dev_priv->vbt.ddi_port_info[port].supports_dp;
3032
3033 if (intel_bios_is_lspcon_present(dev_priv, port)) {
3034 /*
3035 * Lspcon device needs to be driven with DP connector
3036 * with special detection sequence. So make sure DP
3037 * is initialized before lspcon.
3038 */
3039 init_dp = true;
3040 init_lspcon = true;
3041 init_hdmi = false;
3042 DRM_DEBUG_KMS("VBT says port %c has lspcon\n", port_name(port));
3043 }
3044
3045 if (!init_dp && !init_hdmi) {
3046 DRM_DEBUG_KMS("VBT says port %c is not DVI/HDMI/DP compatible, respect it\n",
3047 port_name(port));
3048 return;
3049 }
3050
3051 intel_dig_port = kzalloc(sizeof(*intel_dig_port), GFP_KERNEL);
3052 if (!intel_dig_port)
3053 return;
3054
3055 intel_encoder = &intel_dig_port->base;
3056 encoder = &intel_encoder->base;
3057
3058 drm_encoder_init(&dev_priv->drm, encoder, &intel_ddi_funcs,
3059 DRM_MODE_ENCODER_TMDS, "DDI %c", port_name(port));
3060
3061 intel_encoder->hotplug = intel_ddi_hotplug;
3062 intel_encoder->compute_output_type = intel_ddi_compute_output_type;
3063 intel_encoder->compute_config = intel_ddi_compute_config;
3064 intel_encoder->enable = intel_enable_ddi;
3065 if (IS_GEN9_LP(dev_priv))
3066 intel_encoder->pre_pll_enable = bxt_ddi_pre_pll_enable;
3067 intel_encoder->pre_enable = intel_ddi_pre_enable;
3068 intel_encoder->disable = intel_disable_ddi;
3069 intel_encoder->post_disable = intel_ddi_post_disable;
3070 intel_encoder->get_hw_state = intel_ddi_get_hw_state;
3071 intel_encoder->get_config = intel_ddi_get_config;
3072 intel_encoder->suspend = intel_dp_encoder_suspend;
3073 intel_encoder->get_power_domains = intel_ddi_get_power_domains;
3074 intel_encoder->type = INTEL_OUTPUT_DDI;
3075 intel_encoder->power_domain = intel_port_to_power_domain(port);
3076 intel_encoder->port = port;
3077 intel_encoder->crtc_mask = (1 << 0) | (1 << 1) | (1 << 2);
3078 intel_encoder->cloneable = 0;
3079
3080 if (INTEL_GEN(dev_priv) >= 11)
3081 intel_dig_port->saved_port_bits = I915_READ(DDI_BUF_CTL(port)) &
3082 DDI_BUF_PORT_REVERSAL;
3083 else
3084 intel_dig_port->saved_port_bits = I915_READ(DDI_BUF_CTL(port)) &
3085 (DDI_BUF_PORT_REVERSAL | DDI_A_4_LANES);
3086 intel_dig_port->dp.output_reg = INVALID_MMIO_REG;
3087 intel_dig_port->max_lanes = intel_ddi_max_lanes(intel_dig_port);
3088
3089 switch (port) {
3090 case PORT_A:
3091 intel_dig_port->ddi_io_power_domain =
3092 POWER_DOMAIN_PORT_DDI_A_IO;
3093 break;
3094 case PORT_B:
3095 intel_dig_port->ddi_io_power_domain =
3096 POWER_DOMAIN_PORT_DDI_B_IO;
3097 break;
3098 case PORT_C:
3099 intel_dig_port->ddi_io_power_domain =
3100 POWER_DOMAIN_PORT_DDI_C_IO;
3101 break;
3102 case PORT_D:
3103 intel_dig_port->ddi_io_power_domain =
3104 POWER_DOMAIN_PORT_DDI_D_IO;
3105 break;
3106 case PORT_E:
3107 intel_dig_port->ddi_io_power_domain =
3108 POWER_DOMAIN_PORT_DDI_E_IO;
3109 break;
3110 case PORT_F:
3111 intel_dig_port->ddi_io_power_domain =
3112 POWER_DOMAIN_PORT_DDI_F_IO;
3113 break;
3114 default:
3115 MISSING_CASE(port);
3116 }
3117
3118 intel_infoframe_init(intel_dig_port);
3119
3120 if (init_dp) {
3121 if (!intel_ddi_init_dp_connector(intel_dig_port))
3122 goto err;
3123
3124 intel_dig_port->hpd_pulse = intel_dp_hpd_pulse;
3125 dev_priv->hotplug.irq_port[port] = intel_dig_port;
3126 }
3127
3128 /* In theory we don't need the encoder->type check, but leave it just in
3129 * case we have some really bad VBTs... */
3130 if (intel_encoder->type != INTEL_OUTPUT_EDP && init_hdmi) {
3131 if (!intel_ddi_init_hdmi_connector(intel_dig_port))
3132 goto err;
3133 }
3134
3135 if (init_lspcon) {
3136 if (lspcon_init(intel_dig_port))
3137 /* TODO: handle hdmi info frame part */
3138 DRM_DEBUG_KMS("LSPCON init success on port %c\n",
3139 port_name(port));
3140 else
3141 /*
3142 * LSPCON init faied, but DP init was success, so
3143 * lets try to drive as DP++ port.
3144 */
3145 DRM_ERROR("LSPCON init failed on port %c\n",
3146 port_name(port));
3147 }
3148
3149 return;
3150
3151err:
3152 drm_encoder_cleanup(encoder);
3153 kfree(intel_dig_port);
3154}