2 * Copyright © 2006-2017 Intel Corporation
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
24 #include <linux/time.h>
28 #include "intel_atomic.h"
29 #include "intel_atomic_plane.h"
30 #include "intel_audio.h"
32 #include "intel_cdclk.h"
33 #include "intel_crtc.h"
36 #include "intel_display_types.h"
37 #include "intel_mchbar_regs.h"
38 #include "intel_pci_config.h"
39 #include "intel_pcode.h"
40 #include "intel_psr.h"
41 #include "intel_vdsc.h"
42 #include "vlv_sideband.h"
47 * The display engine uses several different clocks to do its work. There
48 * are two main clocks involved that aren't directly related to the actual
49 * pixel clock or any symbol/bit clock of the actual output port. These
50 * are the core display clock (CDCLK) and RAWCLK.
52 * CDCLK clocks most of the display pipe logic, and thus its frequency
53 * must be high enough to support the rate at which pixels are flowing
54 * through the pipes. Downscaling must also be accounted as that increases
55 * the effective pixel rate.
57 * On several platforms the CDCLK frequency can be changed dynamically
58 * to minimize power consumption for a given display configuration.
59 * Typically changes to the CDCLK frequency require all the display pipes
60 * to be shut down while the frequency is being changed.
62 * On SKL+ the DMC will toggle the CDCLK off/on during DC5/6 entry/exit.
63 * DMC will not change the active CDCLK frequency however, so that part
64 * will still be performed by the driver directly.
66 * RAWCLK is a fixed frequency clock, often used by various auxiliary
67 * blocks such as AUX CH or backlight PWM. Hence the only thing we
68 * really need to know about RAWCLK is its frequency so that various
69 * dividers can be programmed correctly.
72 struct intel_cdclk_funcs
{
73 void (*get_cdclk
)(struct drm_i915_private
*i915
,
74 struct intel_cdclk_config
*cdclk_config
);
75 void (*set_cdclk
)(struct drm_i915_private
*i915
,
76 const struct intel_cdclk_config
*cdclk_config
,
78 int (*modeset_calc_cdclk
)(struct intel_cdclk_state
*state
);
79 u8 (*calc_voltage_level
)(int cdclk
);
82 void intel_cdclk_get_cdclk(struct drm_i915_private
*dev_priv
,
83 struct intel_cdclk_config
*cdclk_config
)
85 dev_priv
->display
.funcs
.cdclk
->get_cdclk(dev_priv
, cdclk_config
);
88 static void intel_cdclk_set_cdclk(struct drm_i915_private
*dev_priv
,
89 const struct intel_cdclk_config
*cdclk_config
,
92 dev_priv
->display
.funcs
.cdclk
->set_cdclk(dev_priv
, cdclk_config
, pipe
);
95 static int intel_cdclk_modeset_calc_cdclk(struct drm_i915_private
*dev_priv
,
96 struct intel_cdclk_state
*cdclk_config
)
98 return dev_priv
->display
.funcs
.cdclk
->modeset_calc_cdclk(cdclk_config
);
101 static u8
intel_cdclk_calc_voltage_level(struct drm_i915_private
*dev_priv
,
104 return dev_priv
->display
.funcs
.cdclk
->calc_voltage_level(cdclk
);
107 static void fixed_133mhz_get_cdclk(struct drm_i915_private
*dev_priv
,
108 struct intel_cdclk_config
*cdclk_config
)
110 cdclk_config
->cdclk
= 133333;
113 static void fixed_200mhz_get_cdclk(struct drm_i915_private
*dev_priv
,
114 struct intel_cdclk_config
*cdclk_config
)
116 cdclk_config
->cdclk
= 200000;
119 static void fixed_266mhz_get_cdclk(struct drm_i915_private
*dev_priv
,
120 struct intel_cdclk_config
*cdclk_config
)
122 cdclk_config
->cdclk
= 266667;
125 static void fixed_333mhz_get_cdclk(struct drm_i915_private
*dev_priv
,
126 struct intel_cdclk_config
*cdclk_config
)
128 cdclk_config
->cdclk
= 333333;
131 static void fixed_400mhz_get_cdclk(struct drm_i915_private
*dev_priv
,
132 struct intel_cdclk_config
*cdclk_config
)
134 cdclk_config
->cdclk
= 400000;
137 static void fixed_450mhz_get_cdclk(struct drm_i915_private
*dev_priv
,
138 struct intel_cdclk_config
*cdclk_config
)
140 cdclk_config
->cdclk
= 450000;
143 static void i85x_get_cdclk(struct drm_i915_private
*dev_priv
,
144 struct intel_cdclk_config
*cdclk_config
)
146 struct pci_dev
*pdev
= to_pci_dev(dev_priv
->drm
.dev
);
150 * 852GM/852GMV only supports 133 MHz and the HPLLCC
151 * encoding is different :(
152 * FIXME is this the right way to detect 852GM/852GMV?
154 if (pdev
->revision
== 0x1) {
155 cdclk_config
->cdclk
= 133333;
159 pci_bus_read_config_word(pdev
->bus
,
160 PCI_DEVFN(0, 3), HPLLCC
, &hpllcc
);
162 /* Assume that the hardware is in the high speed state. This
163 * should be the default.
165 switch (hpllcc
& GC_CLOCK_CONTROL_MASK
) {
166 case GC_CLOCK_133_200
:
167 case GC_CLOCK_133_200_2
:
168 case GC_CLOCK_100_200
:
169 cdclk_config
->cdclk
= 200000;
171 case GC_CLOCK_166_250
:
172 cdclk_config
->cdclk
= 250000;
174 case GC_CLOCK_100_133
:
175 cdclk_config
->cdclk
= 133333;
177 case GC_CLOCK_133_266
:
178 case GC_CLOCK_133_266_2
:
179 case GC_CLOCK_166_266
:
180 cdclk_config
->cdclk
= 266667;
185 static void i915gm_get_cdclk(struct drm_i915_private
*dev_priv
,
186 struct intel_cdclk_config
*cdclk_config
)
188 struct pci_dev
*pdev
= to_pci_dev(dev_priv
->drm
.dev
);
191 pci_read_config_word(pdev
, GCFGC
, &gcfgc
);
193 if (gcfgc
& GC_LOW_FREQUENCY_ENABLE
) {
194 cdclk_config
->cdclk
= 133333;
198 switch (gcfgc
& GC_DISPLAY_CLOCK_MASK
) {
199 case GC_DISPLAY_CLOCK_333_320_MHZ
:
200 cdclk_config
->cdclk
= 333333;
203 case GC_DISPLAY_CLOCK_190_200_MHZ
:
204 cdclk_config
->cdclk
= 190000;
209 static void i945gm_get_cdclk(struct drm_i915_private
*dev_priv
,
210 struct intel_cdclk_config
*cdclk_config
)
212 struct pci_dev
*pdev
= to_pci_dev(dev_priv
->drm
.dev
);
215 pci_read_config_word(pdev
, GCFGC
, &gcfgc
);
217 if (gcfgc
& GC_LOW_FREQUENCY_ENABLE
) {
218 cdclk_config
->cdclk
= 133333;
222 switch (gcfgc
& GC_DISPLAY_CLOCK_MASK
) {
223 case GC_DISPLAY_CLOCK_333_320_MHZ
:
224 cdclk_config
->cdclk
= 320000;
227 case GC_DISPLAY_CLOCK_190_200_MHZ
:
228 cdclk_config
->cdclk
= 200000;
233 static unsigned int intel_hpll_vco(struct drm_i915_private
*dev_priv
)
235 static const unsigned int blb_vco
[8] = {
242 static const unsigned int pnv_vco
[8] = {
249 static const unsigned int cl_vco
[8] = {
258 static const unsigned int elk_vco
[8] = {
264 static const unsigned int ctg_vco
[8] = {
272 const unsigned int *vco_table
;
276 /* FIXME other chipsets? */
277 if (IS_GM45(dev_priv
))
279 else if (IS_G45(dev_priv
))
281 else if (IS_I965GM(dev_priv
))
283 else if (IS_PINEVIEW(dev_priv
))
285 else if (IS_G33(dev_priv
))
290 tmp
= intel_de_read(dev_priv
,
291 IS_PINEVIEW(dev_priv
) || IS_MOBILE(dev_priv
) ? HPLLVCO_MOBILE
: HPLLVCO
);
293 vco
= vco_table
[tmp
& 0x7];
295 drm_err(&dev_priv
->drm
, "Bad HPLL VCO (HPLLVCO=0x%02x)\n",
298 drm_dbg_kms(&dev_priv
->drm
, "HPLL VCO %u kHz\n", vco
);
303 static void g33_get_cdclk(struct drm_i915_private
*dev_priv
,
304 struct intel_cdclk_config
*cdclk_config
)
306 struct pci_dev
*pdev
= to_pci_dev(dev_priv
->drm
.dev
);
307 static const u8 div_3200
[] = { 12, 10, 8, 7, 5, 16 };
308 static const u8 div_4000
[] = { 14, 12, 10, 8, 6, 20 };
309 static const u8 div_4800
[] = { 20, 14, 12, 10, 8, 24 };
310 static const u8 div_5333
[] = { 20, 16, 12, 12, 8, 28 };
312 unsigned int cdclk_sel
;
315 cdclk_config
->vco
= intel_hpll_vco(dev_priv
);
317 pci_read_config_word(pdev
, GCFGC
, &tmp
);
319 cdclk_sel
= (tmp
>> 4) & 0x7;
321 if (cdclk_sel
>= ARRAY_SIZE(div_3200
))
324 switch (cdclk_config
->vco
) {
326 div_table
= div_3200
;
329 div_table
= div_4000
;
332 div_table
= div_4800
;
335 div_table
= div_5333
;
341 cdclk_config
->cdclk
= DIV_ROUND_CLOSEST(cdclk_config
->vco
,
342 div_table
[cdclk_sel
]);
346 drm_err(&dev_priv
->drm
,
347 "Unable to determine CDCLK. HPLL VCO=%u kHz, CFGC=0x%08x\n",
348 cdclk_config
->vco
, tmp
);
349 cdclk_config
->cdclk
= 190476;
352 static void pnv_get_cdclk(struct drm_i915_private
*dev_priv
,
353 struct intel_cdclk_config
*cdclk_config
)
355 struct pci_dev
*pdev
= to_pci_dev(dev_priv
->drm
.dev
);
358 pci_read_config_word(pdev
, GCFGC
, &gcfgc
);
360 switch (gcfgc
& GC_DISPLAY_CLOCK_MASK
) {
361 case GC_DISPLAY_CLOCK_267_MHZ_PNV
:
362 cdclk_config
->cdclk
= 266667;
364 case GC_DISPLAY_CLOCK_333_MHZ_PNV
:
365 cdclk_config
->cdclk
= 333333;
367 case GC_DISPLAY_CLOCK_444_MHZ_PNV
:
368 cdclk_config
->cdclk
= 444444;
370 case GC_DISPLAY_CLOCK_200_MHZ_PNV
:
371 cdclk_config
->cdclk
= 200000;
374 drm_err(&dev_priv
->drm
,
375 "Unknown pnv display core clock 0x%04x\n", gcfgc
);
377 case GC_DISPLAY_CLOCK_133_MHZ_PNV
:
378 cdclk_config
->cdclk
= 133333;
380 case GC_DISPLAY_CLOCK_167_MHZ_PNV
:
381 cdclk_config
->cdclk
= 166667;
386 static void i965gm_get_cdclk(struct drm_i915_private
*dev_priv
,
387 struct intel_cdclk_config
*cdclk_config
)
389 struct pci_dev
*pdev
= to_pci_dev(dev_priv
->drm
.dev
);
390 static const u8 div_3200
[] = { 16, 10, 8 };
391 static const u8 div_4000
[] = { 20, 12, 10 };
392 static const u8 div_5333
[] = { 24, 16, 14 };
394 unsigned int cdclk_sel
;
397 cdclk_config
->vco
= intel_hpll_vco(dev_priv
);
399 pci_read_config_word(pdev
, GCFGC
, &tmp
);
401 cdclk_sel
= ((tmp
>> 8) & 0x1f) - 1;
403 if (cdclk_sel
>= ARRAY_SIZE(div_3200
))
406 switch (cdclk_config
->vco
) {
408 div_table
= div_3200
;
411 div_table
= div_4000
;
414 div_table
= div_5333
;
420 cdclk_config
->cdclk
= DIV_ROUND_CLOSEST(cdclk_config
->vco
,
421 div_table
[cdclk_sel
]);
425 drm_err(&dev_priv
->drm
,
426 "Unable to determine CDCLK. HPLL VCO=%u kHz, CFGC=0x%04x\n",
427 cdclk_config
->vco
, tmp
);
428 cdclk_config
->cdclk
= 200000;
431 static void gm45_get_cdclk(struct drm_i915_private
*dev_priv
,
432 struct intel_cdclk_config
*cdclk_config
)
434 struct pci_dev
*pdev
= to_pci_dev(dev_priv
->drm
.dev
);
435 unsigned int cdclk_sel
;
438 cdclk_config
->vco
= intel_hpll_vco(dev_priv
);
440 pci_read_config_word(pdev
, GCFGC
, &tmp
);
442 cdclk_sel
= (tmp
>> 12) & 0x1;
444 switch (cdclk_config
->vco
) {
448 cdclk_config
->cdclk
= cdclk_sel
? 333333 : 222222;
451 cdclk_config
->cdclk
= cdclk_sel
? 320000 : 228571;
454 drm_err(&dev_priv
->drm
,
455 "Unable to determine CDCLK. HPLL VCO=%u, CFGC=0x%04x\n",
456 cdclk_config
->vco
, tmp
);
457 cdclk_config
->cdclk
= 222222;
462 static void hsw_get_cdclk(struct drm_i915_private
*dev_priv
,
463 struct intel_cdclk_config
*cdclk_config
)
465 u32 lcpll
= intel_de_read(dev_priv
, LCPLL_CTL
);
466 u32 freq
= lcpll
& LCPLL_CLK_FREQ_MASK
;
468 if (lcpll
& LCPLL_CD_SOURCE_FCLK
)
469 cdclk_config
->cdclk
= 800000;
470 else if (intel_de_read(dev_priv
, FUSE_STRAP
) & HSW_CDCLK_LIMIT
)
471 cdclk_config
->cdclk
= 450000;
472 else if (freq
== LCPLL_CLK_FREQ_450
)
473 cdclk_config
->cdclk
= 450000;
474 else if (IS_HASWELL_ULT(dev_priv
))
475 cdclk_config
->cdclk
= 337500;
477 cdclk_config
->cdclk
= 540000;
480 static int vlv_calc_cdclk(struct drm_i915_private
*dev_priv
, int min_cdclk
)
482 int freq_320
= (dev_priv
->hpll_freq
<< 1) % 320000 != 0 ?
486 * We seem to get an unstable or solid color picture at 200MHz.
487 * Not sure what's wrong. For now use 200MHz only when all pipes
490 if (IS_VALLEYVIEW(dev_priv
) && min_cdclk
> freq_320
)
492 else if (min_cdclk
> 266667)
494 else if (min_cdclk
> 0)
500 static u8
vlv_calc_voltage_level(struct drm_i915_private
*dev_priv
, int cdclk
)
502 if (IS_VALLEYVIEW(dev_priv
)) {
503 if (cdclk
>= 320000) /* jump to highest voltage for 400MHz too */
505 else if (cdclk
>= 266667)
511 * Specs are full of misinformation, but testing on actual
512 * hardware has shown that we just need to write the desired
513 * CCK divider into the Punit register.
515 return DIV_ROUND_CLOSEST(dev_priv
->hpll_freq
<< 1, cdclk
) - 1;
519 static void vlv_get_cdclk(struct drm_i915_private
*dev_priv
,
520 struct intel_cdclk_config
*cdclk_config
)
524 vlv_iosf_sb_get(dev_priv
,
525 BIT(VLV_IOSF_SB_CCK
) | BIT(VLV_IOSF_SB_PUNIT
));
527 cdclk_config
->vco
= vlv_get_hpll_vco(dev_priv
);
528 cdclk_config
->cdclk
= vlv_get_cck_clock(dev_priv
, "cdclk",
529 CCK_DISPLAY_CLOCK_CONTROL
,
532 val
= vlv_punit_read(dev_priv
, PUNIT_REG_DSPSSPM
);
534 vlv_iosf_sb_put(dev_priv
,
535 BIT(VLV_IOSF_SB_CCK
) | BIT(VLV_IOSF_SB_PUNIT
));
537 if (IS_VALLEYVIEW(dev_priv
))
538 cdclk_config
->voltage_level
= (val
& DSPFREQGUAR_MASK
) >>
541 cdclk_config
->voltage_level
= (val
& DSPFREQGUAR_MASK_CHV
) >>
542 DSPFREQGUAR_SHIFT_CHV
;
545 static void vlv_program_pfi_credits(struct drm_i915_private
*dev_priv
)
547 unsigned int credits
, default_credits
;
549 if (IS_CHERRYVIEW(dev_priv
))
550 default_credits
= PFI_CREDIT(12);
552 default_credits
= PFI_CREDIT(8);
554 if (dev_priv
->display
.cdclk
.hw
.cdclk
>= dev_priv
->czclk_freq
) {
555 /* CHV suggested value is 31 or 63 */
556 if (IS_CHERRYVIEW(dev_priv
))
557 credits
= PFI_CREDIT_63
;
559 credits
= PFI_CREDIT(15);
561 credits
= default_credits
;
565 * WA - write default credits before re-programming
566 * FIXME: should we also set the resend bit here?
568 intel_de_write(dev_priv
, GCI_CONTROL
,
569 VGA_FAST_MODE_DISABLE
| default_credits
);
571 intel_de_write(dev_priv
, GCI_CONTROL
,
572 VGA_FAST_MODE_DISABLE
| credits
| PFI_CREDIT_RESEND
);
575 * FIXME is this guaranteed to clear
576 * immediately or should we poll for it?
578 drm_WARN_ON(&dev_priv
->drm
,
579 intel_de_read(dev_priv
, GCI_CONTROL
) & PFI_CREDIT_RESEND
);
582 static void vlv_set_cdclk(struct drm_i915_private
*dev_priv
,
583 const struct intel_cdclk_config
*cdclk_config
,
586 int cdclk
= cdclk_config
->cdclk
;
587 u32 val
, cmd
= cdclk_config
->voltage_level
;
588 intel_wakeref_t wakeref
;
602 /* There are cases where we can end up here with power domains
603 * off and a CDCLK frequency other than the minimum, like when
604 * issuing a modeset without actually changing any display after
605 * a system suspend. So grab the display core domain, which covers
606 * the HW blocks needed for the following programming.
608 wakeref
= intel_display_power_get(dev_priv
, POWER_DOMAIN_DISPLAY_CORE
);
610 vlv_iosf_sb_get(dev_priv
,
611 BIT(VLV_IOSF_SB_CCK
) |
612 BIT(VLV_IOSF_SB_BUNIT
) |
613 BIT(VLV_IOSF_SB_PUNIT
));
615 val
= vlv_punit_read(dev_priv
, PUNIT_REG_DSPSSPM
);
616 val
&= ~DSPFREQGUAR_MASK
;
617 val
|= (cmd
<< DSPFREQGUAR_SHIFT
);
618 vlv_punit_write(dev_priv
, PUNIT_REG_DSPSSPM
, val
);
619 if (wait_for((vlv_punit_read(dev_priv
, PUNIT_REG_DSPSSPM
) &
620 DSPFREQSTAT_MASK
) == (cmd
<< DSPFREQSTAT_SHIFT
),
622 drm_err(&dev_priv
->drm
,
623 "timed out waiting for CDclk change\n");
626 if (cdclk
== 400000) {
629 divider
= DIV_ROUND_CLOSEST(dev_priv
->hpll_freq
<< 1,
632 /* adjust cdclk divider */
633 val
= vlv_cck_read(dev_priv
, CCK_DISPLAY_CLOCK_CONTROL
);
634 val
&= ~CCK_FREQUENCY_VALUES
;
636 vlv_cck_write(dev_priv
, CCK_DISPLAY_CLOCK_CONTROL
, val
);
638 if (wait_for((vlv_cck_read(dev_priv
, CCK_DISPLAY_CLOCK_CONTROL
) &
639 CCK_FREQUENCY_STATUS
) == (divider
<< CCK_FREQUENCY_STATUS_SHIFT
),
641 drm_err(&dev_priv
->drm
,
642 "timed out waiting for CDclk change\n");
645 /* adjust self-refresh exit latency value */
646 val
= vlv_bunit_read(dev_priv
, BUNIT_REG_BISOC
);
650 * For high bandwidth configs, we set a higher latency in the bunit
651 * so that the core display fetch happens in time to avoid underruns.
654 val
|= 4500 / 250; /* 4.5 usec */
656 val
|= 3000 / 250; /* 3.0 usec */
657 vlv_bunit_write(dev_priv
, BUNIT_REG_BISOC
, val
);
659 vlv_iosf_sb_put(dev_priv
,
660 BIT(VLV_IOSF_SB_CCK
) |
661 BIT(VLV_IOSF_SB_BUNIT
) |
662 BIT(VLV_IOSF_SB_PUNIT
));
664 intel_update_cdclk(dev_priv
);
666 vlv_program_pfi_credits(dev_priv
);
668 intel_display_power_put(dev_priv
, POWER_DOMAIN_DISPLAY_CORE
, wakeref
);
671 static void chv_set_cdclk(struct drm_i915_private
*dev_priv
,
672 const struct intel_cdclk_config
*cdclk_config
,
675 int cdclk
= cdclk_config
->cdclk
;
676 u32 val
, cmd
= cdclk_config
->voltage_level
;
677 intel_wakeref_t wakeref
;
690 /* There are cases where we can end up here with power domains
691 * off and a CDCLK frequency other than the minimum, like when
692 * issuing a modeset without actually changing any display after
693 * a system suspend. So grab the display core domain, which covers
694 * the HW blocks needed for the following programming.
696 wakeref
= intel_display_power_get(dev_priv
, POWER_DOMAIN_DISPLAY_CORE
);
698 vlv_punit_get(dev_priv
);
699 val
= vlv_punit_read(dev_priv
, PUNIT_REG_DSPSSPM
);
700 val
&= ~DSPFREQGUAR_MASK_CHV
;
701 val
|= (cmd
<< DSPFREQGUAR_SHIFT_CHV
);
702 vlv_punit_write(dev_priv
, PUNIT_REG_DSPSSPM
, val
);
703 if (wait_for((vlv_punit_read(dev_priv
, PUNIT_REG_DSPSSPM
) &
704 DSPFREQSTAT_MASK_CHV
) == (cmd
<< DSPFREQSTAT_SHIFT_CHV
),
706 drm_err(&dev_priv
->drm
,
707 "timed out waiting for CDclk change\n");
710 vlv_punit_put(dev_priv
);
712 intel_update_cdclk(dev_priv
);
714 vlv_program_pfi_credits(dev_priv
);
716 intel_display_power_put(dev_priv
, POWER_DOMAIN_DISPLAY_CORE
, wakeref
);
719 static int bdw_calc_cdclk(int min_cdclk
)
721 if (min_cdclk
> 540000)
723 else if (min_cdclk
> 450000)
725 else if (min_cdclk
> 337500)
731 static u8
bdw_calc_voltage_level(int cdclk
)
746 static void bdw_get_cdclk(struct drm_i915_private
*dev_priv
,
747 struct intel_cdclk_config
*cdclk_config
)
749 u32 lcpll
= intel_de_read(dev_priv
, LCPLL_CTL
);
750 u32 freq
= lcpll
& LCPLL_CLK_FREQ_MASK
;
752 if (lcpll
& LCPLL_CD_SOURCE_FCLK
)
753 cdclk_config
->cdclk
= 800000;
754 else if (intel_de_read(dev_priv
, FUSE_STRAP
) & HSW_CDCLK_LIMIT
)
755 cdclk_config
->cdclk
= 450000;
756 else if (freq
== LCPLL_CLK_FREQ_450
)
757 cdclk_config
->cdclk
= 450000;
758 else if (freq
== LCPLL_CLK_FREQ_54O_BDW
)
759 cdclk_config
->cdclk
= 540000;
760 else if (freq
== LCPLL_CLK_FREQ_337_5_BDW
)
761 cdclk_config
->cdclk
= 337500;
763 cdclk_config
->cdclk
= 675000;
766 * Can't read this out :( Let's assume it's
767 * at least what the CDCLK frequency requires.
769 cdclk_config
->voltage_level
=
770 bdw_calc_voltage_level(cdclk_config
->cdclk
);
773 static u32
bdw_cdclk_freq_sel(int cdclk
)
780 return LCPLL_CLK_FREQ_337_5_BDW
;
782 return LCPLL_CLK_FREQ_450
;
784 return LCPLL_CLK_FREQ_54O_BDW
;
786 return LCPLL_CLK_FREQ_675_BDW
;
790 static void bdw_set_cdclk(struct drm_i915_private
*dev_priv
,
791 const struct intel_cdclk_config
*cdclk_config
,
794 int cdclk
= cdclk_config
->cdclk
;
797 if (drm_WARN(&dev_priv
->drm
,
798 (intel_de_read(dev_priv
, LCPLL_CTL
) &
799 (LCPLL_PLL_DISABLE
| LCPLL_PLL_LOCK
|
800 LCPLL_CD_CLOCK_DISABLE
| LCPLL_ROOT_CD_CLOCK_DISABLE
|
801 LCPLL_CD2X_CLOCK_DISABLE
| LCPLL_POWER_DOWN_ALLOW
|
802 LCPLL_CD_SOURCE_FCLK
)) != LCPLL_PLL_LOCK
,
803 "trying to change cdclk frequency with cdclk not enabled\n"))
806 ret
= snb_pcode_write(&dev_priv
->uncore
, BDW_PCODE_DISPLAY_FREQ_CHANGE_REQ
, 0x0);
808 drm_err(&dev_priv
->drm
,
809 "failed to inform pcode about cdclk change\n");
813 intel_de_rmw(dev_priv
, LCPLL_CTL
,
814 0, LCPLL_CD_SOURCE_FCLK
);
817 * According to the spec, it should be enough to poll for this 1 us.
818 * However, extensive testing shows that this can take longer.
820 if (wait_for_us(intel_de_read(dev_priv
, LCPLL_CTL
) &
821 LCPLL_CD_SOURCE_FCLK_DONE
, 100))
822 drm_err(&dev_priv
->drm
, "Switching to FCLK failed\n");
824 intel_de_rmw(dev_priv
, LCPLL_CTL
,
825 LCPLL_CLK_FREQ_MASK
, bdw_cdclk_freq_sel(cdclk
));
827 intel_de_rmw(dev_priv
, LCPLL_CTL
,
828 LCPLL_CD_SOURCE_FCLK
, 0);
830 if (wait_for_us((intel_de_read(dev_priv
, LCPLL_CTL
) &
831 LCPLL_CD_SOURCE_FCLK_DONE
) == 0, 1))
832 drm_err(&dev_priv
->drm
, "Switching back to LCPLL failed\n");
834 snb_pcode_write(&dev_priv
->uncore
, HSW_PCODE_DE_WRITE_FREQ_REQ
,
835 cdclk_config
->voltage_level
);
837 intel_de_write(dev_priv
, CDCLK_FREQ
,
838 DIV_ROUND_CLOSEST(cdclk
, 1000) - 1);
840 intel_update_cdclk(dev_priv
);
843 static int skl_calc_cdclk(int min_cdclk
, int vco
)
845 if (vco
== 8640000) {
846 if (min_cdclk
> 540000)
848 else if (min_cdclk
> 432000)
850 else if (min_cdclk
> 308571)
855 if (min_cdclk
> 540000)
857 else if (min_cdclk
> 450000)
859 else if (min_cdclk
> 337500)
866 static u8
skl_calc_voltage_level(int cdclk
)
870 else if (cdclk
> 450000)
872 else if (cdclk
> 337500)
878 static void skl_dpll0_update(struct drm_i915_private
*dev_priv
,
879 struct intel_cdclk_config
*cdclk_config
)
883 cdclk_config
->ref
= 24000;
884 cdclk_config
->vco
= 0;
886 val
= intel_de_read(dev_priv
, LCPLL1_CTL
);
887 if ((val
& LCPLL_PLL_ENABLE
) == 0)
890 if (drm_WARN_ON(&dev_priv
->drm
, (val
& LCPLL_PLL_LOCK
) == 0))
893 val
= intel_de_read(dev_priv
, DPLL_CTRL1
);
895 if (drm_WARN_ON(&dev_priv
->drm
,
896 (val
& (DPLL_CTRL1_HDMI_MODE(SKL_DPLL0
) |
897 DPLL_CTRL1_SSC(SKL_DPLL0
) |
898 DPLL_CTRL1_OVERRIDE(SKL_DPLL0
))) !=
899 DPLL_CTRL1_OVERRIDE(SKL_DPLL0
)))
902 switch (val
& DPLL_CTRL1_LINK_RATE_MASK(SKL_DPLL0
)) {
903 case DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_810
, SKL_DPLL0
):
904 case DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_1350
, SKL_DPLL0
):
905 case DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_1620
, SKL_DPLL0
):
906 case DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_2700
, SKL_DPLL0
):
907 cdclk_config
->vco
= 8100000;
909 case DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_1080
, SKL_DPLL0
):
910 case DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_2160
, SKL_DPLL0
):
911 cdclk_config
->vco
= 8640000;
914 MISSING_CASE(val
& DPLL_CTRL1_LINK_RATE_MASK(SKL_DPLL0
));
919 static void skl_get_cdclk(struct drm_i915_private
*dev_priv
,
920 struct intel_cdclk_config
*cdclk_config
)
924 skl_dpll0_update(dev_priv
, cdclk_config
);
926 cdclk_config
->cdclk
= cdclk_config
->bypass
= cdclk_config
->ref
;
928 if (cdclk_config
->vco
== 0)
931 cdctl
= intel_de_read(dev_priv
, CDCLK_CTL
);
933 if (cdclk_config
->vco
== 8640000) {
934 switch (cdctl
& CDCLK_FREQ_SEL_MASK
) {
935 case CDCLK_FREQ_450_432
:
936 cdclk_config
->cdclk
= 432000;
938 case CDCLK_FREQ_337_308
:
939 cdclk_config
->cdclk
= 308571;
942 cdclk_config
->cdclk
= 540000;
944 case CDCLK_FREQ_675_617
:
945 cdclk_config
->cdclk
= 617143;
948 MISSING_CASE(cdctl
& CDCLK_FREQ_SEL_MASK
);
952 switch (cdctl
& CDCLK_FREQ_SEL_MASK
) {
953 case CDCLK_FREQ_450_432
:
954 cdclk_config
->cdclk
= 450000;
956 case CDCLK_FREQ_337_308
:
957 cdclk_config
->cdclk
= 337500;
960 cdclk_config
->cdclk
= 540000;
962 case CDCLK_FREQ_675_617
:
963 cdclk_config
->cdclk
= 675000;
966 MISSING_CASE(cdctl
& CDCLK_FREQ_SEL_MASK
);
973 * Can't read this out :( Let's assume it's
974 * at least what the CDCLK frequency requires.
976 cdclk_config
->voltage_level
=
977 skl_calc_voltage_level(cdclk_config
->cdclk
);
980 /* convert from kHz to .1 fixpoint MHz with -1MHz offset */
981 static int skl_cdclk_decimal(int cdclk
)
983 return DIV_ROUND_CLOSEST(cdclk
- 1000, 500);
986 static void skl_set_preferred_cdclk_vco(struct drm_i915_private
*dev_priv
,
989 bool changed
= dev_priv
->skl_preferred_vco_freq
!= vco
;
991 dev_priv
->skl_preferred_vco_freq
= vco
;
994 intel_update_max_cdclk(dev_priv
);
997 static u32
skl_dpll0_link_rate(struct drm_i915_private
*dev_priv
, int vco
)
999 drm_WARN_ON(&dev_priv
->drm
, vco
!= 8100000 && vco
!= 8640000);
1002 * We always enable DPLL0 with the lowest link rate possible, but still
1003 * taking into account the VCO required to operate the eDP panel at the
1004 * desired frequency. The usual DP link rates operate with a VCO of
1005 * 8100 while the eDP 1.4 alternate link rates need a VCO of 8640.
1006 * The modeset code is responsible for the selection of the exact link
1007 * rate later on, with the constraint of choosing a frequency that
1011 return DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_1080
, SKL_DPLL0
);
1013 return DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_810
, SKL_DPLL0
);
1016 static void skl_dpll0_enable(struct drm_i915_private
*dev_priv
, int vco
)
1018 intel_de_rmw(dev_priv
, DPLL_CTRL1
,
1019 DPLL_CTRL1_HDMI_MODE(SKL_DPLL0
) |
1020 DPLL_CTRL1_SSC(SKL_DPLL0
) |
1021 DPLL_CTRL1_LINK_RATE_MASK(SKL_DPLL0
),
1022 DPLL_CTRL1_OVERRIDE(SKL_DPLL0
) |
1023 skl_dpll0_link_rate(dev_priv
, vco
));
1024 intel_de_posting_read(dev_priv
, DPLL_CTRL1
);
1026 intel_de_rmw(dev_priv
, LCPLL1_CTL
,
1027 0, LCPLL_PLL_ENABLE
);
1029 if (intel_de_wait_for_set(dev_priv
, LCPLL1_CTL
, LCPLL_PLL_LOCK
, 5))
1030 drm_err(&dev_priv
->drm
, "DPLL0 not locked\n");
1032 dev_priv
->display
.cdclk
.hw
.vco
= vco
;
1034 /* We'll want to keep using the current vco from now on. */
1035 skl_set_preferred_cdclk_vco(dev_priv
, vco
);
1038 static void skl_dpll0_disable(struct drm_i915_private
*dev_priv
)
1040 intel_de_rmw(dev_priv
, LCPLL1_CTL
,
1041 LCPLL_PLL_ENABLE
, 0);
1043 if (intel_de_wait_for_clear(dev_priv
, LCPLL1_CTL
, LCPLL_PLL_LOCK
, 1))
1044 drm_err(&dev_priv
->drm
, "Couldn't disable DPLL0\n");
1046 dev_priv
->display
.cdclk
.hw
.vco
= 0;
1049 static u32
skl_cdclk_freq_sel(struct drm_i915_private
*dev_priv
,
1054 drm_WARN_ON(&dev_priv
->drm
,
1055 cdclk
!= dev_priv
->display
.cdclk
.hw
.bypass
);
1056 drm_WARN_ON(&dev_priv
->drm
, vco
!= 0);
1060 return CDCLK_FREQ_337_308
;
1063 return CDCLK_FREQ_450_432
;
1065 return CDCLK_FREQ_540
;
1068 return CDCLK_FREQ_675_617
;
1072 static void skl_set_cdclk(struct drm_i915_private
*dev_priv
,
1073 const struct intel_cdclk_config
*cdclk_config
,
1076 int cdclk
= cdclk_config
->cdclk
;
1077 int vco
= cdclk_config
->vco
;
1078 u32 freq_select
, cdclk_ctl
;
1082 * Based on WA#1183 CDCLK rates 308 and 617MHz CDCLK rates are
1083 * unsupported on SKL. In theory this should never happen since only
1084 * the eDP1.4 2.16 and 4.32Gbps rates require it, but eDP1.4 is not
1085 * supported on SKL either, see the above WA. WARN whenever trying to
1086 * use the corresponding VCO freq as that always leads to using the
1087 * minimum 308MHz CDCLK.
1089 drm_WARN_ON_ONCE(&dev_priv
->drm
,
1090 IS_SKYLAKE(dev_priv
) && vco
== 8640000);
1092 ret
= skl_pcode_request(&dev_priv
->uncore
, SKL_PCODE_CDCLK_CONTROL
,
1093 SKL_CDCLK_PREPARE_FOR_CHANGE
,
1094 SKL_CDCLK_READY_FOR_CHANGE
,
1095 SKL_CDCLK_READY_FOR_CHANGE
, 3);
1097 drm_err(&dev_priv
->drm
,
1098 "Failed to inform PCU about cdclk change (%d)\n", ret
);
1102 freq_select
= skl_cdclk_freq_sel(dev_priv
, cdclk
, vco
);
1104 if (dev_priv
->display
.cdclk
.hw
.vco
!= 0 &&
1105 dev_priv
->display
.cdclk
.hw
.vco
!= vco
)
1106 skl_dpll0_disable(dev_priv
);
1108 cdclk_ctl
= intel_de_read(dev_priv
, CDCLK_CTL
);
1110 if (dev_priv
->display
.cdclk
.hw
.vco
!= vco
) {
1111 /* Wa Display #1183: skl,kbl,cfl */
1112 cdclk_ctl
&= ~(CDCLK_FREQ_SEL_MASK
| CDCLK_FREQ_DECIMAL_MASK
);
1113 cdclk_ctl
|= freq_select
| skl_cdclk_decimal(cdclk
);
1114 intel_de_write(dev_priv
, CDCLK_CTL
, cdclk_ctl
);
1117 /* Wa Display #1183: skl,kbl,cfl */
1118 cdclk_ctl
|= CDCLK_DIVMUX_CD_OVERRIDE
;
1119 intel_de_write(dev_priv
, CDCLK_CTL
, cdclk_ctl
);
1120 intel_de_posting_read(dev_priv
, CDCLK_CTL
);
1122 if (dev_priv
->display
.cdclk
.hw
.vco
!= vco
)
1123 skl_dpll0_enable(dev_priv
, vco
);
1125 /* Wa Display #1183: skl,kbl,cfl */
1126 cdclk_ctl
&= ~(CDCLK_FREQ_SEL_MASK
| CDCLK_FREQ_DECIMAL_MASK
);
1127 intel_de_write(dev_priv
, CDCLK_CTL
, cdclk_ctl
);
1129 cdclk_ctl
|= freq_select
| skl_cdclk_decimal(cdclk
);
1130 intel_de_write(dev_priv
, CDCLK_CTL
, cdclk_ctl
);
1132 /* Wa Display #1183: skl,kbl,cfl */
1133 cdclk_ctl
&= ~CDCLK_DIVMUX_CD_OVERRIDE
;
1134 intel_de_write(dev_priv
, CDCLK_CTL
, cdclk_ctl
);
1135 intel_de_posting_read(dev_priv
, CDCLK_CTL
);
1137 /* inform PCU of the change */
1138 snb_pcode_write(&dev_priv
->uncore
, SKL_PCODE_CDCLK_CONTROL
,
1139 cdclk_config
->voltage_level
);
1141 intel_update_cdclk(dev_priv
);
1144 static void skl_sanitize_cdclk(struct drm_i915_private
*dev_priv
)
1146 u32 cdctl
, expected
;
1149 * check if the pre-os initialized the display
1150 * There is SWF18 scratchpad register defined which is set by the
1151 * pre-os which can be used by the OS drivers to check the status
1153 if ((intel_de_read(dev_priv
, SWF_ILK(0x18)) & 0x00FFFFFF) == 0)
1156 intel_update_cdclk(dev_priv
);
1157 intel_cdclk_dump_config(dev_priv
, &dev_priv
->display
.cdclk
.hw
, "Current CDCLK");
1159 /* Is PLL enabled and locked ? */
1160 if (dev_priv
->display
.cdclk
.hw
.vco
== 0 ||
1161 dev_priv
->display
.cdclk
.hw
.cdclk
== dev_priv
->display
.cdclk
.hw
.bypass
)
1164 /* DPLL okay; verify the cdclock
1166 * Noticed in some instances that the freq selection is correct but
1167 * decimal part is programmed wrong from BIOS where pre-os does not
1168 * enable display. Verify the same as well.
1170 cdctl
= intel_de_read(dev_priv
, CDCLK_CTL
);
1171 expected
= (cdctl
& CDCLK_FREQ_SEL_MASK
) |
1172 skl_cdclk_decimal(dev_priv
->display
.cdclk
.hw
.cdclk
);
1173 if (cdctl
== expected
)
1174 /* All well; nothing to sanitize */
1178 drm_dbg_kms(&dev_priv
->drm
, "Sanitizing cdclk programmed by pre-os\n");
1180 /* force cdclk programming */
1181 dev_priv
->display
.cdclk
.hw
.cdclk
= 0;
1182 /* force full PLL disable + enable */
1183 dev_priv
->display
.cdclk
.hw
.vco
= ~0;
1186 static void skl_cdclk_init_hw(struct drm_i915_private
*dev_priv
)
1188 struct intel_cdclk_config cdclk_config
;
1190 skl_sanitize_cdclk(dev_priv
);
1192 if (dev_priv
->display
.cdclk
.hw
.cdclk
!= 0 &&
1193 dev_priv
->display
.cdclk
.hw
.vco
!= 0) {
1195 * Use the current vco as our initial
1196 * guess as to what the preferred vco is.
1198 if (dev_priv
->skl_preferred_vco_freq
== 0)
1199 skl_set_preferred_cdclk_vco(dev_priv
,
1200 dev_priv
->display
.cdclk
.hw
.vco
);
1204 cdclk_config
= dev_priv
->display
.cdclk
.hw
;
1206 cdclk_config
.vco
= dev_priv
->skl_preferred_vco_freq
;
1207 if (cdclk_config
.vco
== 0)
1208 cdclk_config
.vco
= 8100000;
1209 cdclk_config
.cdclk
= skl_calc_cdclk(0, cdclk_config
.vco
);
1210 cdclk_config
.voltage_level
= skl_calc_voltage_level(cdclk_config
.cdclk
);
1212 skl_set_cdclk(dev_priv
, &cdclk_config
, INVALID_PIPE
);
1215 static void skl_cdclk_uninit_hw(struct drm_i915_private
*dev_priv
)
1217 struct intel_cdclk_config cdclk_config
= dev_priv
->display
.cdclk
.hw
;
1219 cdclk_config
.cdclk
= cdclk_config
.bypass
;
1220 cdclk_config
.vco
= 0;
1221 cdclk_config
.voltage_level
= skl_calc_voltage_level(cdclk_config
.cdclk
);
1223 skl_set_cdclk(dev_priv
, &cdclk_config
, INVALID_PIPE
);
1226 struct intel_cdclk_vals
{
1233 static const struct intel_cdclk_vals bxt_cdclk_table
[] = {
1234 { .refclk
= 19200, .cdclk
= 144000, .ratio
= 60 },
1235 { .refclk
= 19200, .cdclk
= 288000, .ratio
= 60 },
1236 { .refclk
= 19200, .cdclk
= 384000, .ratio
= 60 },
1237 { .refclk
= 19200, .cdclk
= 576000, .ratio
= 60 },
1238 { .refclk
= 19200, .cdclk
= 624000, .ratio
= 65 },
1242 static const struct intel_cdclk_vals glk_cdclk_table
[] = {
1243 { .refclk
= 19200, .cdclk
= 79200, .ratio
= 33 },
1244 { .refclk
= 19200, .cdclk
= 158400, .ratio
= 33 },
1245 { .refclk
= 19200, .cdclk
= 316800, .ratio
= 33 },
1249 static const struct intel_cdclk_vals icl_cdclk_table
[] = {
1250 { .refclk
= 19200, .cdclk
= 172800, .ratio
= 18 },
1251 { .refclk
= 19200, .cdclk
= 192000, .ratio
= 20 },
1252 { .refclk
= 19200, .cdclk
= 307200, .ratio
= 32 },
1253 { .refclk
= 19200, .cdclk
= 326400, .ratio
= 68 },
1254 { .refclk
= 19200, .cdclk
= 556800, .ratio
= 58 },
1255 { .refclk
= 19200, .cdclk
= 652800, .ratio
= 68 },
1257 { .refclk
= 24000, .cdclk
= 180000, .ratio
= 15 },
1258 { .refclk
= 24000, .cdclk
= 192000, .ratio
= 16 },
1259 { .refclk
= 24000, .cdclk
= 312000, .ratio
= 26 },
1260 { .refclk
= 24000, .cdclk
= 324000, .ratio
= 54 },
1261 { .refclk
= 24000, .cdclk
= 552000, .ratio
= 46 },
1262 { .refclk
= 24000, .cdclk
= 648000, .ratio
= 54 },
1264 { .refclk
= 38400, .cdclk
= 172800, .ratio
= 9 },
1265 { .refclk
= 38400, .cdclk
= 192000, .ratio
= 10 },
1266 { .refclk
= 38400, .cdclk
= 307200, .ratio
= 16 },
1267 { .refclk
= 38400, .cdclk
= 326400, .ratio
= 34 },
1268 { .refclk
= 38400, .cdclk
= 556800, .ratio
= 29 },
1269 { .refclk
= 38400, .cdclk
= 652800, .ratio
= 34 },
1273 static const struct intel_cdclk_vals rkl_cdclk_table
[] = {
1274 { .refclk
= 19200, .cdclk
= 172800, .ratio
= 36 },
1275 { .refclk
= 19200, .cdclk
= 192000, .ratio
= 40 },
1276 { .refclk
= 19200, .cdclk
= 307200, .ratio
= 64 },
1277 { .refclk
= 19200, .cdclk
= 326400, .ratio
= 136 },
1278 { .refclk
= 19200, .cdclk
= 556800, .ratio
= 116 },
1279 { .refclk
= 19200, .cdclk
= 652800, .ratio
= 136 },
1281 { .refclk
= 24000, .cdclk
= 180000, .ratio
= 30 },
1282 { .refclk
= 24000, .cdclk
= 192000, .ratio
= 32 },
1283 { .refclk
= 24000, .cdclk
= 312000, .ratio
= 52 },
1284 { .refclk
= 24000, .cdclk
= 324000, .ratio
= 108 },
1285 { .refclk
= 24000, .cdclk
= 552000, .ratio
= 92 },
1286 { .refclk
= 24000, .cdclk
= 648000, .ratio
= 108 },
1288 { .refclk
= 38400, .cdclk
= 172800, .ratio
= 18 },
1289 { .refclk
= 38400, .cdclk
= 192000, .ratio
= 20 },
1290 { .refclk
= 38400, .cdclk
= 307200, .ratio
= 32 },
1291 { .refclk
= 38400, .cdclk
= 326400, .ratio
= 68 },
1292 { .refclk
= 38400, .cdclk
= 556800, .ratio
= 58 },
1293 { .refclk
= 38400, .cdclk
= 652800, .ratio
= 68 },
1297 static const struct intel_cdclk_vals adlp_a_step_cdclk_table
[] = {
1298 { .refclk
= 19200, .cdclk
= 307200, .ratio
= 32 },
1299 { .refclk
= 19200, .cdclk
= 556800, .ratio
= 58 },
1300 { .refclk
= 19200, .cdclk
= 652800, .ratio
= 68 },
1302 { .refclk
= 24000, .cdclk
= 312000, .ratio
= 26 },
1303 { .refclk
= 24000, .cdclk
= 552000, .ratio
= 46 },
1304 { .refclk
= 24400, .cdclk
= 648000, .ratio
= 54 },
1306 { .refclk
= 38400, .cdclk
= 307200, .ratio
= 16 },
1307 { .refclk
= 38400, .cdclk
= 556800, .ratio
= 29 },
1308 { .refclk
= 38400, .cdclk
= 652800, .ratio
= 34 },
1312 static const struct intel_cdclk_vals adlp_cdclk_table
[] = {
1313 { .refclk
= 19200, .cdclk
= 172800, .ratio
= 27 },
1314 { .refclk
= 19200, .cdclk
= 192000, .ratio
= 20 },
1315 { .refclk
= 19200, .cdclk
= 307200, .ratio
= 32 },
1316 { .refclk
= 19200, .cdclk
= 556800, .ratio
= 58 },
1317 { .refclk
= 19200, .cdclk
= 652800, .ratio
= 68 },
1319 { .refclk
= 24000, .cdclk
= 176000, .ratio
= 22 },
1320 { .refclk
= 24000, .cdclk
= 192000, .ratio
= 16 },
1321 { .refclk
= 24000, .cdclk
= 312000, .ratio
= 26 },
1322 { .refclk
= 24000, .cdclk
= 552000, .ratio
= 46 },
1323 { .refclk
= 24000, .cdclk
= 648000, .ratio
= 54 },
1325 { .refclk
= 38400, .cdclk
= 179200, .ratio
= 14 },
1326 { .refclk
= 38400, .cdclk
= 192000, .ratio
= 10 },
1327 { .refclk
= 38400, .cdclk
= 307200, .ratio
= 16 },
1328 { .refclk
= 38400, .cdclk
= 556800, .ratio
= 29 },
1329 { .refclk
= 38400, .cdclk
= 652800, .ratio
= 34 },
1333 static const struct intel_cdclk_vals rplu_cdclk_table
[] = {
1334 { .refclk
= 19200, .cdclk
= 172800, .ratio
= 27 },
1335 { .refclk
= 19200, .cdclk
= 192000, .ratio
= 20 },
1336 { .refclk
= 19200, .cdclk
= 307200, .ratio
= 32 },
1337 { .refclk
= 19200, .cdclk
= 480000, .ratio
= 50 },
1338 { .refclk
= 19200, .cdclk
= 556800, .ratio
= 58 },
1339 { .refclk
= 19200, .cdclk
= 652800, .ratio
= 68 },
1341 { .refclk
= 24000, .cdclk
= 176000, .ratio
= 22 },
1342 { .refclk
= 24000, .cdclk
= 192000, .ratio
= 16 },
1343 { .refclk
= 24000, .cdclk
= 312000, .ratio
= 26 },
1344 { .refclk
= 24000, .cdclk
= 480000, .ratio
= 40 },
1345 { .refclk
= 24000, .cdclk
= 552000, .ratio
= 46 },
1346 { .refclk
= 24000, .cdclk
= 648000, .ratio
= 54 },
1348 { .refclk
= 38400, .cdclk
= 179200, .ratio
= 14 },
1349 { .refclk
= 38400, .cdclk
= 192000, .ratio
= 10 },
1350 { .refclk
= 38400, .cdclk
= 307200, .ratio
= 16 },
1351 { .refclk
= 38400, .cdclk
= 480000, .ratio
= 25 },
1352 { .refclk
= 38400, .cdclk
= 556800, .ratio
= 29 },
1353 { .refclk
= 38400, .cdclk
= 652800, .ratio
= 34 },
1357 static const struct intel_cdclk_vals dg2_cdclk_table
[] = {
1358 { .refclk
= 38400, .cdclk
= 163200, .ratio
= 34, .waveform
= 0x8888 },
1359 { .refclk
= 38400, .cdclk
= 204000, .ratio
= 34, .waveform
= 0x9248 },
1360 { .refclk
= 38400, .cdclk
= 244800, .ratio
= 34, .waveform
= 0xa4a4 },
1361 { .refclk
= 38400, .cdclk
= 285600, .ratio
= 34, .waveform
= 0xa54a },
1362 { .refclk
= 38400, .cdclk
= 326400, .ratio
= 34, .waveform
= 0xaaaa },
1363 { .refclk
= 38400, .cdclk
= 367200, .ratio
= 34, .waveform
= 0xad5a },
1364 { .refclk
= 38400, .cdclk
= 408000, .ratio
= 34, .waveform
= 0xb6b6 },
1365 { .refclk
= 38400, .cdclk
= 448800, .ratio
= 34, .waveform
= 0xdbb6 },
1366 { .refclk
= 38400, .cdclk
= 489600, .ratio
= 34, .waveform
= 0xeeee },
1367 { .refclk
= 38400, .cdclk
= 530400, .ratio
= 34, .waveform
= 0xf7de },
1368 { .refclk
= 38400, .cdclk
= 571200, .ratio
= 34, .waveform
= 0xfefe },
1369 { .refclk
= 38400, .cdclk
= 612000, .ratio
= 34, .waveform
= 0xfffe },
1370 { .refclk
= 38400, .cdclk
= 652800, .ratio
= 34, .waveform
= 0xffff },
1374 static const struct intel_cdclk_vals mtl_cdclk_table
[] = {
1375 { .refclk
= 38400, .cdclk
= 172800, .ratio
= 16, .waveform
= 0xad5a },
1376 { .refclk
= 38400, .cdclk
= 192000, .ratio
= 16, .waveform
= 0xb6b6 },
1377 { .refclk
= 38400, .cdclk
= 307200, .ratio
= 16, .waveform
= 0x0000 },
1378 { .refclk
= 38400, .cdclk
= 480000, .ratio
= 25, .waveform
= 0x0000 },
1379 { .refclk
= 38400, .cdclk
= 556800, .ratio
= 29, .waveform
= 0x0000 },
1380 { .refclk
= 38400, .cdclk
= 652800, .ratio
= 34, .waveform
= 0x0000 },
1384 static const struct intel_cdclk_vals lnl_cdclk_table
[] = {
1385 { .refclk
= 38400, .cdclk
= 153600, .ratio
= 16, .waveform
= 0xaaaa },
1386 { .refclk
= 38400, .cdclk
= 172800, .ratio
= 16, .waveform
= 0xad5a },
1387 { .refclk
= 38400, .cdclk
= 192000, .ratio
= 16, .waveform
= 0xb6b6 },
1388 { .refclk
= 38400, .cdclk
= 211200, .ratio
= 16, .waveform
= 0xdbb6 },
1389 { .refclk
= 38400, .cdclk
= 230400, .ratio
= 16, .waveform
= 0xeeee },
1390 { .refclk
= 38400, .cdclk
= 249600, .ratio
= 16, .waveform
= 0xf7de },
1391 { .refclk
= 38400, .cdclk
= 268800, .ratio
= 16, .waveform
= 0xfefe },
1392 { .refclk
= 38400, .cdclk
= 288000, .ratio
= 16, .waveform
= 0xfffe },
1393 { .refclk
= 38400, .cdclk
= 307200, .ratio
= 16, .waveform
= 0xffff },
1394 { .refclk
= 38400, .cdclk
= 330000, .ratio
= 25, .waveform
= 0xdbb6 },
1395 { .refclk
= 38400, .cdclk
= 360000, .ratio
= 25, .waveform
= 0xeeee },
1396 { .refclk
= 38400, .cdclk
= 390000, .ratio
= 25, .waveform
= 0xf7de },
1397 { .refclk
= 38400, .cdclk
= 420000, .ratio
= 25, .waveform
= 0xfefe },
1398 { .refclk
= 38400, .cdclk
= 450000, .ratio
= 25, .waveform
= 0xfffe },
1399 { .refclk
= 38400, .cdclk
= 480000, .ratio
= 25, .waveform
= 0xffff },
1400 { .refclk
= 38400, .cdclk
= 487200, .ratio
= 29, .waveform
= 0xfefe },
1401 { .refclk
= 38400, .cdclk
= 522000, .ratio
= 29, .waveform
= 0xfffe },
1402 { .refclk
= 38400, .cdclk
= 556800, .ratio
= 29, .waveform
= 0xffff },
1403 { .refclk
= 38400, .cdclk
= 571200, .ratio
= 34, .waveform
= 0xfefe },
1404 { .refclk
= 38400, .cdclk
= 612000, .ratio
= 34, .waveform
= 0xfffe },
1405 { .refclk
= 38400, .cdclk
= 652800, .ratio
= 34, .waveform
= 0xffff },
1409 static int bxt_calc_cdclk(struct drm_i915_private
*dev_priv
, int min_cdclk
)
1411 const struct intel_cdclk_vals
*table
= dev_priv
->display
.cdclk
.table
;
1414 for (i
= 0; table
[i
].refclk
; i
++)
1415 if (table
[i
].refclk
== dev_priv
->display
.cdclk
.hw
.ref
&&
1416 table
[i
].cdclk
>= min_cdclk
)
1417 return table
[i
].cdclk
;
1419 drm_WARN(&dev_priv
->drm
, 1,
1420 "Cannot satisfy minimum cdclk %d with refclk %u\n",
1421 min_cdclk
, dev_priv
->display
.cdclk
.hw
.ref
);
1425 static int bxt_calc_cdclk_pll_vco(struct drm_i915_private
*dev_priv
, int cdclk
)
1427 const struct intel_cdclk_vals
*table
= dev_priv
->display
.cdclk
.table
;
1430 if (cdclk
== dev_priv
->display
.cdclk
.hw
.bypass
)
1433 for (i
= 0; table
[i
].refclk
; i
++)
1434 if (table
[i
].refclk
== dev_priv
->display
.cdclk
.hw
.ref
&&
1435 table
[i
].cdclk
== cdclk
)
1436 return dev_priv
->display
.cdclk
.hw
.ref
* table
[i
].ratio
;
1438 drm_WARN(&dev_priv
->drm
, 1, "cdclk %d not valid for refclk %u\n",
1439 cdclk
, dev_priv
->display
.cdclk
.hw
.ref
);
1443 static u8
bxt_calc_voltage_level(int cdclk
)
1445 return DIV_ROUND_UP(cdclk
, 25000);
1448 static u8
calc_voltage_level(int cdclk
, int num_voltage_levels
,
1449 const int voltage_level_max_cdclk
[])
1453 for (voltage_level
= 0; voltage_level
< num_voltage_levels
; voltage_level
++) {
1454 if (cdclk
<= voltage_level_max_cdclk
[voltage_level
])
1455 return voltage_level
;
1458 MISSING_CASE(cdclk
);
1459 return num_voltage_levels
- 1;
1462 static u8
icl_calc_voltage_level(int cdclk
)
1464 static const int icl_voltage_level_max_cdclk
[] = {
1470 return calc_voltage_level(cdclk
,
1471 ARRAY_SIZE(icl_voltage_level_max_cdclk
),
1472 icl_voltage_level_max_cdclk
);
1475 static u8
ehl_calc_voltage_level(int cdclk
)
1477 static const int ehl_voltage_level_max_cdclk
[] = {
1482 * Bspec lists the limit as 556.8 MHz, but some JSL
1483 * development boards (at least) boot with 652.8 MHz
1488 return calc_voltage_level(cdclk
,
1489 ARRAY_SIZE(ehl_voltage_level_max_cdclk
),
1490 ehl_voltage_level_max_cdclk
);
1493 static u8
tgl_calc_voltage_level(int cdclk
)
1495 static const int tgl_voltage_level_max_cdclk
[] = {
1502 return calc_voltage_level(cdclk
,
1503 ARRAY_SIZE(tgl_voltage_level_max_cdclk
),
1504 tgl_voltage_level_max_cdclk
);
1507 static u8
rplu_calc_voltage_level(int cdclk
)
1509 static const int rplu_voltage_level_max_cdclk
[] = {
1516 return calc_voltage_level(cdclk
,
1517 ARRAY_SIZE(rplu_voltage_level_max_cdclk
),
1518 rplu_voltage_level_max_cdclk
);
1521 static void icl_readout_refclk(struct drm_i915_private
*dev_priv
,
1522 struct intel_cdclk_config
*cdclk_config
)
1524 u32 dssm
= intel_de_read(dev_priv
, SKL_DSSM
) & ICL_DSSM_CDCLK_PLL_REFCLK_MASK
;
1530 case ICL_DSSM_CDCLK_PLL_REFCLK_24MHz
:
1531 cdclk_config
->ref
= 24000;
1533 case ICL_DSSM_CDCLK_PLL_REFCLK_19_2MHz
:
1534 cdclk_config
->ref
= 19200;
1536 case ICL_DSSM_CDCLK_PLL_REFCLK_38_4MHz
:
1537 cdclk_config
->ref
= 38400;
1542 static void bxt_de_pll_readout(struct drm_i915_private
*dev_priv
,
1543 struct intel_cdclk_config
*cdclk_config
)
1547 if (IS_DG2(dev_priv
))
1548 cdclk_config
->ref
= 38400;
1549 else if (DISPLAY_VER(dev_priv
) >= 11)
1550 icl_readout_refclk(dev_priv
, cdclk_config
);
1552 cdclk_config
->ref
= 19200;
1554 val
= intel_de_read(dev_priv
, BXT_DE_PLL_ENABLE
);
1555 if ((val
& BXT_DE_PLL_PLL_ENABLE
) == 0 ||
1556 (val
& BXT_DE_PLL_LOCK
) == 0) {
1558 * CDCLK PLL is disabled, the VCO/ratio doesn't matter, but
1559 * setting it to zero is a way to signal that.
1561 cdclk_config
->vco
= 0;
1566 * DISPLAY_VER >= 11 have the ratio directly in the PLL enable register,
1567 * gen9lp had it in a separate PLL control register.
1569 if (DISPLAY_VER(dev_priv
) >= 11)
1570 ratio
= val
& ICL_CDCLK_PLL_RATIO_MASK
;
1572 ratio
= intel_de_read(dev_priv
, BXT_DE_PLL_CTL
) & BXT_DE_PLL_RATIO_MASK
;
1574 cdclk_config
->vco
= ratio
* cdclk_config
->ref
;
1577 static void bxt_get_cdclk(struct drm_i915_private
*dev_priv
,
1578 struct intel_cdclk_config
*cdclk_config
)
1584 bxt_de_pll_readout(dev_priv
, cdclk_config
);
1586 if (DISPLAY_VER(dev_priv
) >= 12)
1587 cdclk_config
->bypass
= cdclk_config
->ref
/ 2;
1588 else if (DISPLAY_VER(dev_priv
) >= 11)
1589 cdclk_config
->bypass
= 50000;
1591 cdclk_config
->bypass
= cdclk_config
->ref
;
1593 if (cdclk_config
->vco
== 0) {
1594 cdclk_config
->cdclk
= cdclk_config
->bypass
;
1598 divider
= intel_de_read(dev_priv
, CDCLK_CTL
) & BXT_CDCLK_CD2X_DIV_SEL_MASK
;
1601 case BXT_CDCLK_CD2X_DIV_SEL_1
:
1604 case BXT_CDCLK_CD2X_DIV_SEL_1_5
:
1607 case BXT_CDCLK_CD2X_DIV_SEL_2
:
1610 case BXT_CDCLK_CD2X_DIV_SEL_4
:
1614 MISSING_CASE(divider
);
1618 if (HAS_CDCLK_SQUASH(dev_priv
))
1619 squash_ctl
= intel_de_read(dev_priv
, CDCLK_SQUASH_CTL
);
1621 if (squash_ctl
& CDCLK_SQUASH_ENABLE
) {
1625 size
= REG_FIELD_GET(CDCLK_SQUASH_WINDOW_SIZE_MASK
, squash_ctl
) + 1;
1626 waveform
= REG_FIELD_GET(CDCLK_SQUASH_WAVEFORM_MASK
, squash_ctl
) >> (16 - size
);
1628 cdclk_config
->cdclk
= DIV_ROUND_CLOSEST(hweight16(waveform
) *
1629 cdclk_config
->vco
, size
* div
);
1631 cdclk_config
->cdclk
= DIV_ROUND_CLOSEST(cdclk_config
->vco
, div
);
1636 * Can't read this out :( Let's assume it's
1637 * at least what the CDCLK frequency requires.
1639 cdclk_config
->voltage_level
=
1640 intel_cdclk_calc_voltage_level(dev_priv
, cdclk_config
->cdclk
);
1643 static void bxt_de_pll_disable(struct drm_i915_private
*dev_priv
)
1645 intel_de_write(dev_priv
, BXT_DE_PLL_ENABLE
, 0);
1648 if (intel_de_wait_for_clear(dev_priv
,
1649 BXT_DE_PLL_ENABLE
, BXT_DE_PLL_LOCK
, 1))
1650 drm_err(&dev_priv
->drm
, "timeout waiting for DE PLL unlock\n");
1652 dev_priv
->display
.cdclk
.hw
.vco
= 0;
1655 static void bxt_de_pll_enable(struct drm_i915_private
*dev_priv
, int vco
)
1657 int ratio
= DIV_ROUND_CLOSEST(vco
, dev_priv
->display
.cdclk
.hw
.ref
);
1659 intel_de_rmw(dev_priv
, BXT_DE_PLL_CTL
,
1660 BXT_DE_PLL_RATIO_MASK
, BXT_DE_PLL_RATIO(ratio
));
1662 intel_de_write(dev_priv
, BXT_DE_PLL_ENABLE
, BXT_DE_PLL_PLL_ENABLE
);
1665 if (intel_de_wait_for_set(dev_priv
,
1666 BXT_DE_PLL_ENABLE
, BXT_DE_PLL_LOCK
, 1))
1667 drm_err(&dev_priv
->drm
, "timeout waiting for DE PLL lock\n");
1669 dev_priv
->display
.cdclk
.hw
.vco
= vco
;
1672 static void icl_cdclk_pll_disable(struct drm_i915_private
*dev_priv
)
1674 intel_de_rmw(dev_priv
, BXT_DE_PLL_ENABLE
,
1675 BXT_DE_PLL_PLL_ENABLE
, 0);
1678 if (intel_de_wait_for_clear(dev_priv
, BXT_DE_PLL_ENABLE
, BXT_DE_PLL_LOCK
, 1))
1679 drm_err(&dev_priv
->drm
, "timeout waiting for CDCLK PLL unlock\n");
1681 dev_priv
->display
.cdclk
.hw
.vco
= 0;
1684 static void icl_cdclk_pll_enable(struct drm_i915_private
*dev_priv
, int vco
)
1686 int ratio
= DIV_ROUND_CLOSEST(vco
, dev_priv
->display
.cdclk
.hw
.ref
);
1689 val
= ICL_CDCLK_PLL_RATIO(ratio
);
1690 intel_de_write(dev_priv
, BXT_DE_PLL_ENABLE
, val
);
1692 val
|= BXT_DE_PLL_PLL_ENABLE
;
1693 intel_de_write(dev_priv
, BXT_DE_PLL_ENABLE
, val
);
1696 if (intel_de_wait_for_set(dev_priv
, BXT_DE_PLL_ENABLE
, BXT_DE_PLL_LOCK
, 1))
1697 drm_err(&dev_priv
->drm
, "timeout waiting for CDCLK PLL lock\n");
1699 dev_priv
->display
.cdclk
.hw
.vco
= vco
;
1702 static void adlp_cdclk_pll_crawl(struct drm_i915_private
*dev_priv
, int vco
)
1704 int ratio
= DIV_ROUND_CLOSEST(vco
, dev_priv
->display
.cdclk
.hw
.ref
);
1707 /* Write PLL ratio without disabling */
1708 val
= ICL_CDCLK_PLL_RATIO(ratio
) | BXT_DE_PLL_PLL_ENABLE
;
1709 intel_de_write(dev_priv
, BXT_DE_PLL_ENABLE
, val
);
1711 /* Submit freq change request */
1712 val
|= BXT_DE_PLL_FREQ_REQ
;
1713 intel_de_write(dev_priv
, BXT_DE_PLL_ENABLE
, val
);
1716 if (intel_de_wait_for_set(dev_priv
, BXT_DE_PLL_ENABLE
,
1717 BXT_DE_PLL_LOCK
| BXT_DE_PLL_FREQ_REQ_ACK
, 1))
1718 drm_err(&dev_priv
->drm
, "timeout waiting for FREQ change request ack\n");
1720 val
&= ~BXT_DE_PLL_FREQ_REQ
;
1721 intel_de_write(dev_priv
, BXT_DE_PLL_ENABLE
, val
);
1723 dev_priv
->display
.cdclk
.hw
.vco
= vco
;
1726 static u32
bxt_cdclk_cd2x_pipe(struct drm_i915_private
*dev_priv
, enum pipe pipe
)
1728 if (DISPLAY_VER(dev_priv
) >= 12) {
1729 if (pipe
== INVALID_PIPE
)
1730 return TGL_CDCLK_CD2X_PIPE_NONE
;
1732 return TGL_CDCLK_CD2X_PIPE(pipe
);
1733 } else if (DISPLAY_VER(dev_priv
) >= 11) {
1734 if (pipe
== INVALID_PIPE
)
1735 return ICL_CDCLK_CD2X_PIPE_NONE
;
1737 return ICL_CDCLK_CD2X_PIPE(pipe
);
1739 if (pipe
== INVALID_PIPE
)
1740 return BXT_CDCLK_CD2X_PIPE_NONE
;
1742 return BXT_CDCLK_CD2X_PIPE(pipe
);
1746 static u32
bxt_cdclk_cd2x_div_sel(struct drm_i915_private
*dev_priv
,
1749 /* cdclk = vco / 2 / div{1,1.5,2,4} */
1750 switch (DIV_ROUND_CLOSEST(vco
, cdclk
)) {
1752 drm_WARN_ON(&dev_priv
->drm
,
1753 cdclk
!= dev_priv
->display
.cdclk
.hw
.bypass
);
1754 drm_WARN_ON(&dev_priv
->drm
, vco
!= 0);
1757 return BXT_CDCLK_CD2X_DIV_SEL_1
;
1759 return BXT_CDCLK_CD2X_DIV_SEL_1_5
;
1761 return BXT_CDCLK_CD2X_DIV_SEL_2
;
1763 return BXT_CDCLK_CD2X_DIV_SEL_4
;
1767 static u32
cdclk_squash_waveform(struct drm_i915_private
*dev_priv
,
1770 const struct intel_cdclk_vals
*table
= dev_priv
->display
.cdclk
.table
;
1773 if (cdclk
== dev_priv
->display
.cdclk
.hw
.bypass
)
1776 for (i
= 0; table
[i
].refclk
; i
++)
1777 if (table
[i
].refclk
== dev_priv
->display
.cdclk
.hw
.ref
&&
1778 table
[i
].cdclk
== cdclk
)
1779 return table
[i
].waveform
;
1781 drm_WARN(&dev_priv
->drm
, 1, "cdclk %d not valid for refclk %u\n",
1782 cdclk
, dev_priv
->display
.cdclk
.hw
.ref
);
1787 static void icl_cdclk_pll_update(struct drm_i915_private
*i915
, int vco
)
1789 if (i915
->display
.cdclk
.hw
.vco
!= 0 &&
1790 i915
->display
.cdclk
.hw
.vco
!= vco
)
1791 icl_cdclk_pll_disable(i915
);
1793 if (i915
->display
.cdclk
.hw
.vco
!= vco
)
1794 icl_cdclk_pll_enable(i915
, vco
);
1797 static void bxt_cdclk_pll_update(struct drm_i915_private
*i915
, int vco
)
1799 if (i915
->display
.cdclk
.hw
.vco
!= 0 &&
1800 i915
->display
.cdclk
.hw
.vco
!= vco
)
1801 bxt_de_pll_disable(i915
);
1803 if (i915
->display
.cdclk
.hw
.vco
!= vco
)
1804 bxt_de_pll_enable(i915
, vco
);
1807 static void dg2_cdclk_squash_program(struct drm_i915_private
*i915
,
1813 squash_ctl
= CDCLK_SQUASH_ENABLE
|
1814 CDCLK_SQUASH_WINDOW_SIZE(0xf) | waveform
;
1816 intel_de_write(i915
, CDCLK_SQUASH_CTL
, squash_ctl
);
1819 static bool cdclk_pll_is_unknown(unsigned int vco
)
1822 * Ensure driver does not take the crawl path for the
1823 * case when the vco is set to ~0 in the
1829 static const int cdclk_squash_len
= 16;
1831 static int cdclk_squash_divider(u16 waveform
)
1833 return hweight16(waveform
?: 0xffff);
1836 static bool cdclk_compute_crawl_and_squash_midpoint(struct drm_i915_private
*i915
,
1837 const struct intel_cdclk_config
*old_cdclk_config
,
1838 const struct intel_cdclk_config
*new_cdclk_config
,
1839 struct intel_cdclk_config
*mid_cdclk_config
)
1841 u16 old_waveform
, new_waveform
, mid_waveform
;
1844 /* Return if PLL is in an unknown state, force a complete disable and re-enable. */
1845 if (cdclk_pll_is_unknown(old_cdclk_config
->vco
))
1848 /* Return if both Squash and Crawl are not present */
1849 if (!HAS_CDCLK_CRAWL(i915
) || !HAS_CDCLK_SQUASH(i915
))
1852 old_waveform
= cdclk_squash_waveform(i915
, old_cdclk_config
->cdclk
);
1853 new_waveform
= cdclk_squash_waveform(i915
, new_cdclk_config
->cdclk
);
1855 /* Return if Squash only or Crawl only is the desired action */
1856 if (old_cdclk_config
->vco
== 0 || new_cdclk_config
->vco
== 0 ||
1857 old_cdclk_config
->vco
== new_cdclk_config
->vco
||
1858 old_waveform
== new_waveform
)
1861 *mid_cdclk_config
= *new_cdclk_config
;
1864 * Populate the mid_cdclk_config accordingly.
1865 * - If moving to a higher cdclk, the desired action is squashing.
1866 * The mid cdclk config should have the new (squash) waveform.
1867 * - If moving to a lower cdclk, the desired action is crawling.
1868 * The mid cdclk config should have the new vco.
1871 if (cdclk_squash_divider(new_waveform
) > cdclk_squash_divider(old_waveform
)) {
1872 mid_cdclk_config
->vco
= old_cdclk_config
->vco
;
1873 mid_waveform
= new_waveform
;
1875 mid_cdclk_config
->vco
= new_cdclk_config
->vco
;
1876 mid_waveform
= old_waveform
;
1879 mid_cdclk_config
->cdclk
= DIV_ROUND_CLOSEST(cdclk_squash_divider(mid_waveform
) *
1880 mid_cdclk_config
->vco
,
1881 cdclk_squash_len
* div
);
1883 /* make sure the mid clock came out sane */
1885 drm_WARN_ON(&i915
->drm
, mid_cdclk_config
->cdclk
<
1886 min(old_cdclk_config
->cdclk
, new_cdclk_config
->cdclk
));
1887 drm_WARN_ON(&i915
->drm
, mid_cdclk_config
->cdclk
>
1888 i915
->display
.cdclk
.max_cdclk_freq
);
1889 drm_WARN_ON(&i915
->drm
, cdclk_squash_waveform(i915
, mid_cdclk_config
->cdclk
) !=
1895 static bool pll_enable_wa_needed(struct drm_i915_private
*dev_priv
)
1897 return (DISPLAY_VER_FULL(dev_priv
) == IP_VER(20, 0) ||
1898 DISPLAY_VER_FULL(dev_priv
) == IP_VER(14, 0) ||
1899 IS_DG2(dev_priv
)) &&
1900 dev_priv
->display
.cdclk
.hw
.vco
> 0;
1903 static u32
bxt_cdclk_ctl(struct drm_i915_private
*i915
,
1904 const struct intel_cdclk_config
*cdclk_config
,
1907 int cdclk
= cdclk_config
->cdclk
;
1908 int vco
= cdclk_config
->vco
;
1909 int unsquashed_cdclk
;
1913 waveform
= cdclk_squash_waveform(i915
, cdclk
);
1915 unsquashed_cdclk
= DIV_ROUND_CLOSEST(cdclk
* cdclk_squash_len
,
1916 cdclk_squash_divider(waveform
));
1918 val
= bxt_cdclk_cd2x_div_sel(i915
, unsquashed_cdclk
, vco
) |
1919 bxt_cdclk_cd2x_pipe(i915
, pipe
);
1922 * Disable SSA Precharge when CD clock frequency < 500 MHz,
1925 if ((IS_GEMINILAKE(i915
) || IS_BROXTON(i915
)) &&
1927 val
|= BXT_CDCLK_SSA_PRECHARGE_ENABLE
;
1929 if (DISPLAY_VER(i915
) >= 20)
1930 val
|= MDCLK_SOURCE_SEL_CDCLK_PLL
;
1932 val
|= skl_cdclk_decimal(cdclk
);
1937 static void _bxt_set_cdclk(struct drm_i915_private
*dev_priv
,
1938 const struct intel_cdclk_config
*cdclk_config
,
1941 int cdclk
= cdclk_config
->cdclk
;
1942 int vco
= cdclk_config
->vco
;
1945 if (HAS_CDCLK_CRAWL(dev_priv
) && dev_priv
->display
.cdclk
.hw
.vco
> 0 && vco
> 0 &&
1946 !cdclk_pll_is_unknown(dev_priv
->display
.cdclk
.hw
.vco
)) {
1947 if (dev_priv
->display
.cdclk
.hw
.vco
!= vco
)
1948 adlp_cdclk_pll_crawl(dev_priv
, vco
);
1949 } else if (DISPLAY_VER(dev_priv
) >= 11) {
1950 /* wa_15010685871: dg2, mtl */
1951 if (pll_enable_wa_needed(dev_priv
))
1952 dg2_cdclk_squash_program(dev_priv
, 0);
1954 icl_cdclk_pll_update(dev_priv
, vco
);
1956 bxt_cdclk_pll_update(dev_priv
, vco
);
1958 waveform
= cdclk_squash_waveform(dev_priv
, cdclk
);
1960 if (HAS_CDCLK_SQUASH(dev_priv
))
1961 dg2_cdclk_squash_program(dev_priv
, waveform
);
1963 intel_de_write(dev_priv
, CDCLK_CTL
, bxt_cdclk_ctl(dev_priv
, cdclk_config
, pipe
));
1965 if (pipe
!= INVALID_PIPE
)
1966 intel_crtc_wait_for_next_vblank(intel_crtc_for_pipe(dev_priv
, pipe
));
1969 static void bxt_set_cdclk(struct drm_i915_private
*dev_priv
,
1970 const struct intel_cdclk_config
*cdclk_config
,
1973 struct intel_cdclk_config mid_cdclk_config
;
1974 int cdclk
= cdclk_config
->cdclk
;
1978 * Inform power controller of upcoming frequency change.
1979 * Display versions 14 and beyond do not follow the PUnit
1980 * mailbox communication, skip
1983 if (DISPLAY_VER(dev_priv
) >= 14 || IS_DG2(dev_priv
))
1985 else if (DISPLAY_VER(dev_priv
) >= 11)
1986 ret
= skl_pcode_request(&dev_priv
->uncore
, SKL_PCODE_CDCLK_CONTROL
,
1987 SKL_CDCLK_PREPARE_FOR_CHANGE
,
1988 SKL_CDCLK_READY_FOR_CHANGE
,
1989 SKL_CDCLK_READY_FOR_CHANGE
, 3);
1992 * BSpec requires us to wait up to 150usec, but that leads to
1993 * timeouts; the 2ms used here is based on experiment.
1995 ret
= snb_pcode_write_timeout(&dev_priv
->uncore
,
1996 HSW_PCODE_DE_WRITE_FREQ_REQ
,
1997 0x80000000, 150, 2);
2000 drm_err(&dev_priv
->drm
,
2001 "Failed to inform PCU about cdclk change (err %d, freq %d)\n",
2006 if (cdclk_compute_crawl_and_squash_midpoint(dev_priv
, &dev_priv
->display
.cdclk
.hw
,
2007 cdclk_config
, &mid_cdclk_config
)) {
2008 _bxt_set_cdclk(dev_priv
, &mid_cdclk_config
, pipe
);
2009 _bxt_set_cdclk(dev_priv
, cdclk_config
, pipe
);
2011 _bxt_set_cdclk(dev_priv
, cdclk_config
, pipe
);
2014 if (DISPLAY_VER(dev_priv
) >= 14)
2016 * NOOP - No Pcode communication needed for
2017 * Display versions 14 and beyond
2019 else if (DISPLAY_VER(dev_priv
) >= 11 && !IS_DG2(dev_priv
))
2020 ret
= snb_pcode_write(&dev_priv
->uncore
, SKL_PCODE_CDCLK_CONTROL
,
2021 cdclk_config
->voltage_level
);
2022 if (DISPLAY_VER(dev_priv
) < 11) {
2024 * The timeout isn't specified, the 2ms used here is based on
2026 * FIXME: Waiting for the request completion could be delayed
2027 * until the next PCODE request based on BSpec.
2029 ret
= snb_pcode_write_timeout(&dev_priv
->uncore
,
2030 HSW_PCODE_DE_WRITE_FREQ_REQ
,
2031 cdclk_config
->voltage_level
,
2035 drm_err(&dev_priv
->drm
,
2036 "PCode CDCLK freq set failed, (err %d, freq %d)\n",
2041 intel_update_cdclk(dev_priv
);
2043 if (DISPLAY_VER(dev_priv
) >= 11)
2045 * Can't read out the voltage level :(
2046 * Let's just assume everything is as expected.
2048 dev_priv
->display
.cdclk
.hw
.voltage_level
= cdclk_config
->voltage_level
;
2051 static void bxt_sanitize_cdclk(struct drm_i915_private
*dev_priv
)
2053 u32 cdctl
, expected
;
2056 intel_update_cdclk(dev_priv
);
2057 intel_cdclk_dump_config(dev_priv
, &dev_priv
->display
.cdclk
.hw
, "Current CDCLK");
2059 if (dev_priv
->display
.cdclk
.hw
.vco
== 0 ||
2060 dev_priv
->display
.cdclk
.hw
.cdclk
== dev_priv
->display
.cdclk
.hw
.bypass
)
2063 /* Make sure this is a legal cdclk value for the platform */
2064 cdclk
= bxt_calc_cdclk(dev_priv
, dev_priv
->display
.cdclk
.hw
.cdclk
);
2065 if (cdclk
!= dev_priv
->display
.cdclk
.hw
.cdclk
)
2068 /* Make sure the VCO is correct for the cdclk */
2069 vco
= bxt_calc_cdclk_pll_vco(dev_priv
, cdclk
);
2070 if (vco
!= dev_priv
->display
.cdclk
.hw
.vco
)
2074 * Some BIOS versions leave an incorrect decimal frequency value and
2075 * set reserved MBZ bits in CDCLK_CTL at least during exiting from S4,
2076 * so sanitize this register.
2078 cdctl
= intel_de_read(dev_priv
, CDCLK_CTL
);
2079 expected
= bxt_cdclk_ctl(dev_priv
, &dev_priv
->display
.cdclk
.hw
, INVALID_PIPE
);
2082 * Let's ignore the pipe field, since BIOS could have configured the
2083 * dividers both synching to an active pipe, or asynchronously
2086 cdctl
&= ~bxt_cdclk_cd2x_pipe(dev_priv
, INVALID_PIPE
);
2087 expected
&= ~bxt_cdclk_cd2x_pipe(dev_priv
, INVALID_PIPE
);
2089 if (cdctl
== expected
)
2090 /* All well; nothing to sanitize */
2094 drm_dbg_kms(&dev_priv
->drm
, "Sanitizing cdclk programmed by pre-os\n");
2096 /* force cdclk programming */
2097 dev_priv
->display
.cdclk
.hw
.cdclk
= 0;
2099 /* force full PLL disable + enable */
2100 dev_priv
->display
.cdclk
.hw
.vco
= ~0;
2103 static void bxt_cdclk_init_hw(struct drm_i915_private
*dev_priv
)
2105 struct intel_cdclk_config cdclk_config
;
2107 bxt_sanitize_cdclk(dev_priv
);
2109 if (dev_priv
->display
.cdclk
.hw
.cdclk
!= 0 &&
2110 dev_priv
->display
.cdclk
.hw
.vco
!= 0)
2113 cdclk_config
= dev_priv
->display
.cdclk
.hw
;
2117 * - The initial CDCLK needs to be read from VBT.
2118 * Need to make this change after VBT has changes for BXT.
2120 cdclk_config
.cdclk
= bxt_calc_cdclk(dev_priv
, 0);
2121 cdclk_config
.vco
= bxt_calc_cdclk_pll_vco(dev_priv
, cdclk_config
.cdclk
);
2122 cdclk_config
.voltage_level
=
2123 intel_cdclk_calc_voltage_level(dev_priv
, cdclk_config
.cdclk
);
2125 bxt_set_cdclk(dev_priv
, &cdclk_config
, INVALID_PIPE
);
2128 static void bxt_cdclk_uninit_hw(struct drm_i915_private
*dev_priv
)
2130 struct intel_cdclk_config cdclk_config
= dev_priv
->display
.cdclk
.hw
;
2132 cdclk_config
.cdclk
= cdclk_config
.bypass
;
2133 cdclk_config
.vco
= 0;
2134 cdclk_config
.voltage_level
=
2135 intel_cdclk_calc_voltage_level(dev_priv
, cdclk_config
.cdclk
);
2137 bxt_set_cdclk(dev_priv
, &cdclk_config
, INVALID_PIPE
);
2141 * intel_cdclk_init_hw - Initialize CDCLK hardware
2142 * @i915: i915 device
2144 * Initialize CDCLK. This consists mainly of initializing dev_priv->display.cdclk.hw and
2145 * sanitizing the state of the hardware if needed. This is generally done only
2146 * during the display core initialization sequence, after which the DMC will
2147 * take care of turning CDCLK off/on as needed.
2149 void intel_cdclk_init_hw(struct drm_i915_private
*i915
)
2151 if (DISPLAY_VER(i915
) >= 10 || IS_BROXTON(i915
))
2152 bxt_cdclk_init_hw(i915
);
2153 else if (DISPLAY_VER(i915
) == 9)
2154 skl_cdclk_init_hw(i915
);
2158 * intel_cdclk_uninit_hw - Uninitialize CDCLK hardware
2159 * @i915: i915 device
2161 * Uninitialize CDCLK. This is done only during the display core
2162 * uninitialization sequence.
2164 void intel_cdclk_uninit_hw(struct drm_i915_private
*i915
)
2166 if (DISPLAY_VER(i915
) >= 10 || IS_BROXTON(i915
))
2167 bxt_cdclk_uninit_hw(i915
);
2168 else if (DISPLAY_VER(i915
) == 9)
2169 skl_cdclk_uninit_hw(i915
);
2172 static bool intel_cdclk_can_crawl_and_squash(struct drm_i915_private
*i915
,
2173 const struct intel_cdclk_config
*a
,
2174 const struct intel_cdclk_config
*b
)
2179 drm_WARN_ON(&i915
->drm
, cdclk_pll_is_unknown(a
->vco
));
2181 if (a
->vco
== 0 || b
->vco
== 0)
2184 if (!HAS_CDCLK_CRAWL(i915
) || !HAS_CDCLK_SQUASH(i915
))
2187 old_waveform
= cdclk_squash_waveform(i915
, a
->cdclk
);
2188 new_waveform
= cdclk_squash_waveform(i915
, b
->cdclk
);
2190 return a
->vco
!= b
->vco
&&
2191 old_waveform
!= new_waveform
;
2194 static bool intel_cdclk_can_crawl(struct drm_i915_private
*dev_priv
,
2195 const struct intel_cdclk_config
*a
,
2196 const struct intel_cdclk_config
*b
)
2200 if (!HAS_CDCLK_CRAWL(dev_priv
))
2204 * The vco and cd2x divider will change independently
2205 * from each, so we disallow cd2x change when crawling.
2207 a_div
= DIV_ROUND_CLOSEST(a
->vco
, a
->cdclk
);
2208 b_div
= DIV_ROUND_CLOSEST(b
->vco
, b
->cdclk
);
2210 return a
->vco
!= 0 && b
->vco
!= 0 &&
2216 static bool intel_cdclk_can_squash(struct drm_i915_private
*dev_priv
,
2217 const struct intel_cdclk_config
*a
,
2218 const struct intel_cdclk_config
*b
)
2221 * FIXME should store a bit more state in intel_cdclk_config
2222 * to differentiate squasher vs. cd2x divider properly. For
2223 * the moment all platforms with squasher use a fixed cd2x
2226 if (!HAS_CDCLK_SQUASH(dev_priv
))
2229 return a
->cdclk
!= b
->cdclk
&&
2236 * intel_cdclk_needs_modeset - Determine if changong between the CDCLK
2237 * configurations requires a modeset on all pipes
2238 * @a: first CDCLK configuration
2239 * @b: second CDCLK configuration
2242 * True if changing between the two CDCLK configurations
2243 * requires all pipes to be off, false if not.
2245 bool intel_cdclk_needs_modeset(const struct intel_cdclk_config
*a
,
2246 const struct intel_cdclk_config
*b
)
2248 return a
->cdclk
!= b
->cdclk
||
2254 * intel_cdclk_can_cd2x_update - Determine if changing between the two CDCLK
2255 * configurations requires only a cd2x divider update
2256 * @dev_priv: i915 device
2257 * @a: first CDCLK configuration
2258 * @b: second CDCLK configuration
2261 * True if changing between the two CDCLK configurations
2262 * can be done with just a cd2x divider update, false if not.
2264 static bool intel_cdclk_can_cd2x_update(struct drm_i915_private
*dev_priv
,
2265 const struct intel_cdclk_config
*a
,
2266 const struct intel_cdclk_config
*b
)
2268 /* Older hw doesn't have the capability */
2269 if (DISPLAY_VER(dev_priv
) < 10 && !IS_BROXTON(dev_priv
))
2273 * FIXME should store a bit more state in intel_cdclk_config
2274 * to differentiate squasher vs. cd2x divider properly. For
2275 * the moment all platforms with squasher use a fixed cd2x
2278 if (HAS_CDCLK_SQUASH(dev_priv
))
2281 return a
->cdclk
!= b
->cdclk
&&
2288 * intel_cdclk_changed - Determine if two CDCLK configurations are different
2289 * @a: first CDCLK configuration
2290 * @b: second CDCLK configuration
2293 * True if the CDCLK configurations don't match, false if they do.
2295 static bool intel_cdclk_changed(const struct intel_cdclk_config
*a
,
2296 const struct intel_cdclk_config
*b
)
2298 return intel_cdclk_needs_modeset(a
, b
) ||
2299 a
->voltage_level
!= b
->voltage_level
;
2302 void intel_cdclk_dump_config(struct drm_i915_private
*i915
,
2303 const struct intel_cdclk_config
*cdclk_config
,
2304 const char *context
)
2306 drm_dbg_kms(&i915
->drm
, "%s %d kHz, VCO %d kHz, ref %d kHz, bypass %d kHz, voltage level %d\n",
2307 context
, cdclk_config
->cdclk
, cdclk_config
->vco
,
2308 cdclk_config
->ref
, cdclk_config
->bypass
,
2309 cdclk_config
->voltage_level
);
2312 static void intel_pcode_notify(struct drm_i915_private
*i915
,
2314 u8 active_pipe_count
,
2316 bool cdclk_update_valid
,
2317 bool pipe_count_update_valid
)
2320 u32 update_mask
= 0;
2325 update_mask
= DISPLAY_TO_PCODE_UPDATE_MASK(cdclk
, active_pipe_count
, voltage_level
);
2327 if (cdclk_update_valid
)
2328 update_mask
|= DISPLAY_TO_PCODE_CDCLK_VALID
;
2330 if (pipe_count_update_valid
)
2331 update_mask
|= DISPLAY_TO_PCODE_PIPE_COUNT_VALID
;
2333 ret
= skl_pcode_request(&i915
->uncore
, SKL_PCODE_CDCLK_CONTROL
,
2334 SKL_CDCLK_PREPARE_FOR_CHANGE
|
2336 SKL_CDCLK_READY_FOR_CHANGE
,
2337 SKL_CDCLK_READY_FOR_CHANGE
, 3);
2340 "Failed to inform PCU about display config (err %d)\n",
2345 * intel_set_cdclk - Push the CDCLK configuration to the hardware
2346 * @dev_priv: i915 device
2347 * @cdclk_config: new CDCLK configuration
2348 * @pipe: pipe with which to synchronize the update
2350 * Program the hardware based on the passed in CDCLK state,
2353 static void intel_set_cdclk(struct drm_i915_private
*dev_priv
,
2354 const struct intel_cdclk_config
*cdclk_config
,
2357 struct intel_encoder
*encoder
;
2359 if (!intel_cdclk_changed(&dev_priv
->display
.cdclk
.hw
, cdclk_config
))
2362 if (drm_WARN_ON_ONCE(&dev_priv
->drm
, !dev_priv
->display
.funcs
.cdclk
->set_cdclk
))
2365 intel_cdclk_dump_config(dev_priv
, cdclk_config
, "Changing CDCLK to");
2367 for_each_intel_encoder_with_psr(&dev_priv
->drm
, encoder
) {
2368 struct intel_dp
*intel_dp
= enc_to_intel_dp(encoder
);
2370 intel_psr_pause(intel_dp
);
2373 intel_audio_cdclk_change_pre(dev_priv
);
2376 * Lock aux/gmbus while we change cdclk in case those
2377 * functions use cdclk. Not all platforms/ports do,
2378 * but we'll lock them all for simplicity.
2380 mutex_lock(&dev_priv
->display
.gmbus
.mutex
);
2381 for_each_intel_dp(&dev_priv
->drm
, encoder
) {
2382 struct intel_dp
*intel_dp
= enc_to_intel_dp(encoder
);
2384 mutex_lock_nest_lock(&intel_dp
->aux
.hw_mutex
,
2385 &dev_priv
->display
.gmbus
.mutex
);
2388 intel_cdclk_set_cdclk(dev_priv
, cdclk_config
, pipe
);
2390 for_each_intel_dp(&dev_priv
->drm
, encoder
) {
2391 struct intel_dp
*intel_dp
= enc_to_intel_dp(encoder
);
2393 mutex_unlock(&intel_dp
->aux
.hw_mutex
);
2395 mutex_unlock(&dev_priv
->display
.gmbus
.mutex
);
2397 for_each_intel_encoder_with_psr(&dev_priv
->drm
, encoder
) {
2398 struct intel_dp
*intel_dp
= enc_to_intel_dp(encoder
);
2400 intel_psr_resume(intel_dp
);
2403 intel_audio_cdclk_change_post(dev_priv
);
2405 if (drm_WARN(&dev_priv
->drm
,
2406 intel_cdclk_changed(&dev_priv
->display
.cdclk
.hw
, cdclk_config
),
2407 "cdclk state doesn't match!\n")) {
2408 intel_cdclk_dump_config(dev_priv
, &dev_priv
->display
.cdclk
.hw
, "[hw state]");
2409 intel_cdclk_dump_config(dev_priv
, cdclk_config
, "[sw state]");
2413 static void intel_cdclk_pcode_pre_notify(struct intel_atomic_state
*state
)
2415 struct drm_i915_private
*i915
= to_i915(state
->base
.dev
);
2416 const struct intel_cdclk_state
*old_cdclk_state
=
2417 intel_atomic_get_old_cdclk_state(state
);
2418 const struct intel_cdclk_state
*new_cdclk_state
=
2419 intel_atomic_get_new_cdclk_state(state
);
2420 unsigned int cdclk
= 0; u8 voltage_level
, num_active_pipes
= 0;
2421 bool change_cdclk
, update_pipe_count
;
2423 if (!intel_cdclk_changed(&old_cdclk_state
->actual
,
2424 &new_cdclk_state
->actual
) &&
2425 new_cdclk_state
->active_pipes
==
2426 old_cdclk_state
->active_pipes
)
2429 /* According to "Sequence Before Frequency Change", voltage level set to 0x3 */
2430 voltage_level
= DISPLAY_TO_PCODE_VOLTAGE_MAX
;
2432 change_cdclk
= new_cdclk_state
->actual
.cdclk
!= old_cdclk_state
->actual
.cdclk
;
2433 update_pipe_count
= hweight8(new_cdclk_state
->active_pipes
) >
2434 hweight8(old_cdclk_state
->active_pipes
);
2437 * According to "Sequence Before Frequency Change",
2438 * if CDCLK is increasing, set bits 25:16 to upcoming CDCLK,
2439 * if CDCLK is decreasing or not changing, set bits 25:16 to current CDCLK,
2440 * which basically means we choose the maximum of old and new CDCLK, if we know both
2443 cdclk
= max(new_cdclk_state
->actual
.cdclk
, old_cdclk_state
->actual
.cdclk
);
2446 * According to "Sequence For Pipe Count Change",
2447 * if pipe count is increasing, set bits 25:16 to upcoming pipe count
2448 * (power well is enabled)
2449 * no action if it is decreasing, before the change
2451 if (update_pipe_count
)
2452 num_active_pipes
= hweight8(new_cdclk_state
->active_pipes
);
2454 intel_pcode_notify(i915
, voltage_level
, num_active_pipes
, cdclk
,
2455 change_cdclk
, update_pipe_count
);
2458 static void intel_cdclk_pcode_post_notify(struct intel_atomic_state
*state
)
2460 struct drm_i915_private
*i915
= to_i915(state
->base
.dev
);
2461 const struct intel_cdclk_state
*new_cdclk_state
=
2462 intel_atomic_get_new_cdclk_state(state
);
2463 const struct intel_cdclk_state
*old_cdclk_state
=
2464 intel_atomic_get_old_cdclk_state(state
);
2465 unsigned int cdclk
= 0; u8 voltage_level
, num_active_pipes
= 0;
2466 bool update_cdclk
, update_pipe_count
;
2468 /* According to "Sequence After Frequency Change", set voltage to used level */
2469 voltage_level
= new_cdclk_state
->actual
.voltage_level
;
2471 update_cdclk
= new_cdclk_state
->actual
.cdclk
!= old_cdclk_state
->actual
.cdclk
;
2472 update_pipe_count
= hweight8(new_cdclk_state
->active_pipes
) <
2473 hweight8(old_cdclk_state
->active_pipes
);
2476 * According to "Sequence After Frequency Change",
2477 * set bits 25:16 to current CDCLK
2480 cdclk
= new_cdclk_state
->actual
.cdclk
;
2483 * According to "Sequence For Pipe Count Change",
2484 * if pipe count is decreasing, set bits 25:16 to current pipe count,
2485 * after the change(power well is disabled)
2486 * no action if it is increasing, after the change
2488 if (update_pipe_count
)
2489 num_active_pipes
= hweight8(new_cdclk_state
->active_pipes
);
2491 intel_pcode_notify(i915
, voltage_level
, num_active_pipes
, cdclk
,
2492 update_cdclk
, update_pipe_count
);
2496 * intel_set_cdclk_pre_plane_update - Push the CDCLK state to the hardware
2497 * @state: intel atomic state
2499 * Program the hardware before updating the HW plane state based on the
2500 * new CDCLK state, if necessary.
2503 intel_set_cdclk_pre_plane_update(struct intel_atomic_state
*state
)
2505 struct drm_i915_private
*i915
= to_i915(state
->base
.dev
);
2506 const struct intel_cdclk_state
*old_cdclk_state
=
2507 intel_atomic_get_old_cdclk_state(state
);
2508 const struct intel_cdclk_state
*new_cdclk_state
=
2509 intel_atomic_get_new_cdclk_state(state
);
2510 enum pipe pipe
= new_cdclk_state
->pipe
;
2512 if (!intel_cdclk_changed(&old_cdclk_state
->actual
,
2513 &new_cdclk_state
->actual
))
2517 intel_cdclk_pcode_pre_notify(state
);
2519 if (pipe
== INVALID_PIPE
||
2520 old_cdclk_state
->actual
.cdclk
<= new_cdclk_state
->actual
.cdclk
) {
2521 drm_WARN_ON(&i915
->drm
, !new_cdclk_state
->base
.changed
);
2523 intel_set_cdclk(i915
, &new_cdclk_state
->actual
, pipe
);
2528 * intel_set_cdclk_post_plane_update - Push the CDCLK state to the hardware
2529 * @state: intel atomic state
2531 * Program the hardware after updating the HW plane state based on the
2532 * new CDCLK state, if necessary.
2535 intel_set_cdclk_post_plane_update(struct intel_atomic_state
*state
)
2537 struct drm_i915_private
*i915
= to_i915(state
->base
.dev
);
2538 const struct intel_cdclk_state
*old_cdclk_state
=
2539 intel_atomic_get_old_cdclk_state(state
);
2540 const struct intel_cdclk_state
*new_cdclk_state
=
2541 intel_atomic_get_new_cdclk_state(state
);
2542 enum pipe pipe
= new_cdclk_state
->pipe
;
2544 if (!intel_cdclk_changed(&old_cdclk_state
->actual
,
2545 &new_cdclk_state
->actual
))
2549 intel_cdclk_pcode_post_notify(state
);
2551 if (pipe
!= INVALID_PIPE
&&
2552 old_cdclk_state
->actual
.cdclk
> new_cdclk_state
->actual
.cdclk
) {
2553 drm_WARN_ON(&i915
->drm
, !new_cdclk_state
->base
.changed
);
2555 intel_set_cdclk(i915
, &new_cdclk_state
->actual
, pipe
);
2559 static int intel_pixel_rate_to_cdclk(const struct intel_crtc_state
*crtc_state
)
2561 struct drm_i915_private
*dev_priv
= to_i915(crtc_state
->uapi
.crtc
->dev
);
2562 int pixel_rate
= crtc_state
->pixel_rate
;
2564 if (DISPLAY_VER(dev_priv
) >= 10)
2565 return DIV_ROUND_UP(pixel_rate
, 2);
2566 else if (DISPLAY_VER(dev_priv
) == 9 ||
2567 IS_BROADWELL(dev_priv
) || IS_HASWELL(dev_priv
))
2569 else if (IS_CHERRYVIEW(dev_priv
))
2570 return DIV_ROUND_UP(pixel_rate
* 100, 95);
2571 else if (crtc_state
->double_wide
)
2572 return DIV_ROUND_UP(pixel_rate
* 100, 90 * 2);
2574 return DIV_ROUND_UP(pixel_rate
* 100, 90);
2577 static int intel_planes_min_cdclk(const struct intel_crtc_state
*crtc_state
)
2579 struct intel_crtc
*crtc
= to_intel_crtc(crtc_state
->uapi
.crtc
);
2580 struct drm_i915_private
*dev_priv
= to_i915(crtc
->base
.dev
);
2581 struct intel_plane
*plane
;
2584 for_each_intel_plane_on_crtc(&dev_priv
->drm
, crtc
, plane
)
2585 min_cdclk
= max(crtc_state
->min_cdclk
[plane
->id
], min_cdclk
);
2590 static int intel_vdsc_min_cdclk(const struct intel_crtc_state
*crtc_state
)
2592 struct intel_crtc
*crtc
= to_intel_crtc(crtc_state
->uapi
.crtc
);
2593 struct drm_i915_private
*i915
= to_i915(crtc
->base
.dev
);
2594 int num_vdsc_instances
= intel_dsc_get_num_vdsc_instances(crtc_state
);
2598 * When we decide to use only one VDSC engine, since
2599 * each VDSC operates with 1 ppc throughput, pixel clock
2600 * cannot be higher than the VDSC clock (cdclk)
2601 * If there 2 VDSC engines, then pixel clock can't be higher than
2602 * VDSC clock(cdclk) * 2 and so on.
2604 min_cdclk
= max_t(int, min_cdclk
,
2605 DIV_ROUND_UP(crtc_state
->pixel_rate
, num_vdsc_instances
));
2607 if (crtc_state
->bigjoiner_pipes
) {
2608 int pixel_clock
= intel_dp_mode_to_fec_clock(crtc_state
->hw
.adjusted_mode
.clock
);
2611 * According to Bigjoiner bw check:
2612 * compressed_bpp <= PPC * CDCLK * Big joiner Interface bits / Pixel clock
2614 * We have already computed compressed_bpp, so now compute the min CDCLK that
2615 * is required to support this compressed_bpp.
2617 * => CDCLK >= compressed_bpp * Pixel clock / (PPC * Bigjoiner Interface bits)
2619 * Since PPC = 2 with bigjoiner
2620 * => CDCLK >= compressed_bpp * Pixel clock / 2 * Bigjoiner Interface bits
2622 int bigjoiner_interface_bits
= DISPLAY_VER(i915
) >= 14 ? 36 : 24;
2624 (to_bpp_int_roundup(crtc_state
->dsc
.compressed_bpp_x16
) *
2625 pixel_clock
) / (2 * bigjoiner_interface_bits
);
2627 min_cdclk
= max(min_cdclk
, min_cdclk_bj
);
2633 int intel_crtc_compute_min_cdclk(const struct intel_crtc_state
*crtc_state
)
2635 struct drm_i915_private
*dev_priv
=
2636 to_i915(crtc_state
->uapi
.crtc
->dev
);
2639 if (!crtc_state
->hw
.enable
)
2642 min_cdclk
= intel_pixel_rate_to_cdclk(crtc_state
);
2644 /* pixel rate mustn't exceed 95% of cdclk with IPS on BDW */
2645 if (IS_BROADWELL(dev_priv
) && hsw_crtc_state_ips_capable(crtc_state
))
2646 min_cdclk
= DIV_ROUND_UP(min_cdclk
* 100, 95);
2648 /* BSpec says "Do not use DisplayPort with CDCLK less than 432 MHz,
2649 * audio enabled, port width x4, and link rate HBR2 (5.4 GHz), or else
2650 * there may be audio corruption or screen corruption." This cdclk
2651 * restriction for GLK is 316.8 MHz.
2653 if (intel_crtc_has_dp_encoder(crtc_state
) &&
2654 crtc_state
->has_audio
&&
2655 crtc_state
->port_clock
>= 540000 &&
2656 crtc_state
->lane_count
== 4) {
2657 if (DISPLAY_VER(dev_priv
) == 10) {
2658 /* Display WA #1145: glk */
2659 min_cdclk
= max(316800, min_cdclk
);
2660 } else if (DISPLAY_VER(dev_priv
) == 9 || IS_BROADWELL(dev_priv
)) {
2661 /* Display WA #1144: skl,bxt */
2662 min_cdclk
= max(432000, min_cdclk
);
2667 * According to BSpec, "The CD clock frequency must be at least twice
2668 * the frequency of the Azalia BCLK." and BCLK is 96 MHz by default.
2670 if (crtc_state
->has_audio
&& DISPLAY_VER(dev_priv
) >= 9)
2671 min_cdclk
= max(2 * 96000, min_cdclk
);
2674 * "For DP audio configuration, cdclk frequency shall be set to
2675 * meet the following requirements:
2676 * DP Link Frequency(MHz) | Cdclk frequency(MHz)
2677 * 270 | 320 or higher
2678 * 162 | 200 or higher"
2680 if ((IS_VALLEYVIEW(dev_priv
) || IS_CHERRYVIEW(dev_priv
)) &&
2681 intel_crtc_has_dp_encoder(crtc_state
) && crtc_state
->has_audio
)
2682 min_cdclk
= max(crtc_state
->port_clock
, min_cdclk
);
2685 * On Valleyview some DSI panels lose (v|h)sync when the clock is lower
2688 if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_DSI
) &&
2689 IS_VALLEYVIEW(dev_priv
))
2690 min_cdclk
= max(320000, min_cdclk
);
2693 * On Geminilake once the CDCLK gets as low as 79200
2694 * picture gets unstable, despite that values are
2695 * correct for DSI PLL and DE PLL.
2697 if (intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_DSI
) &&
2698 IS_GEMINILAKE(dev_priv
))
2699 min_cdclk
= max(158400, min_cdclk
);
2701 /* Account for additional needs from the planes */
2702 min_cdclk
= max(intel_planes_min_cdclk(crtc_state
), min_cdclk
);
2704 if (crtc_state
->dsc
.compression_enable
)
2705 min_cdclk
= max(min_cdclk
, intel_vdsc_min_cdclk(crtc_state
));
2708 * HACK. Currently for TGL/DG2 platforms we calculate
2709 * min_cdclk initially based on pixel_rate divided
2710 * by 2, accounting for also plane requirements,
2711 * however in some cases the lowest possible CDCLK
2712 * doesn't work and causing the underruns.
2713 * Explicitly stating here that this seems to be currently
2714 * rather a Hack, than final solution.
2716 if (IS_TIGERLAKE(dev_priv
) || IS_DG2(dev_priv
)) {
2718 * Clamp to max_cdclk_freq in case pixel rate is higher,
2719 * in order not to break an 8K, but still leave W/A at place.
2721 min_cdclk
= max_t(int, min_cdclk
,
2722 min_t(int, crtc_state
->pixel_rate
,
2723 dev_priv
->display
.cdclk
.max_cdclk_freq
));
2729 static int intel_compute_min_cdclk(struct intel_cdclk_state
*cdclk_state
)
2731 struct intel_atomic_state
*state
= cdclk_state
->base
.state
;
2732 struct drm_i915_private
*dev_priv
= to_i915(state
->base
.dev
);
2733 const struct intel_bw_state
*bw_state
;
2734 struct intel_crtc
*crtc
;
2735 struct intel_crtc_state
*crtc_state
;
2739 for_each_new_intel_crtc_in_state(state
, crtc
, crtc_state
, i
) {
2742 min_cdclk
= intel_crtc_compute_min_cdclk(crtc_state
);
2746 if (cdclk_state
->min_cdclk
[crtc
->pipe
] == min_cdclk
)
2749 cdclk_state
->min_cdclk
[crtc
->pipe
] = min_cdclk
;
2751 ret
= intel_atomic_lock_global_state(&cdclk_state
->base
);
2756 bw_state
= intel_atomic_get_new_bw_state(state
);
2758 min_cdclk
= intel_bw_min_cdclk(dev_priv
, bw_state
);
2760 if (cdclk_state
->bw_min_cdclk
!= min_cdclk
) {
2763 cdclk_state
->bw_min_cdclk
= min_cdclk
;
2765 ret
= intel_atomic_lock_global_state(&cdclk_state
->base
);
2771 min_cdclk
= max(cdclk_state
->force_min_cdclk
,
2772 cdclk_state
->bw_min_cdclk
);
2773 for_each_pipe(dev_priv
, pipe
)
2774 min_cdclk
= max(cdclk_state
->min_cdclk
[pipe
], min_cdclk
);
2777 * Avoid glk_force_audio_cdclk() causing excessive screen
2778 * blinking when multiple pipes are active by making sure
2779 * CDCLK frequency is always high enough for audio. With a
2780 * single active pipe we can always change CDCLK frequency
2781 * by changing the cd2x divider (see glk_cdclk_table[]) and
2782 * thus a full modeset won't be needed then.
2784 if (IS_GEMINILAKE(dev_priv
) && cdclk_state
->active_pipes
&&
2785 !is_power_of_2(cdclk_state
->active_pipes
))
2786 min_cdclk
= max(2 * 96000, min_cdclk
);
2788 if (min_cdclk
> dev_priv
->display
.cdclk
.max_cdclk_freq
) {
2789 drm_dbg_kms(&dev_priv
->drm
,
2790 "required cdclk (%d kHz) exceeds max (%d kHz)\n",
2791 min_cdclk
, dev_priv
->display
.cdclk
.max_cdclk_freq
);
2799 * Account for port clock min voltage level requirements.
2800 * This only really does something on DISPLA_VER >= 11 but can be
2801 * called on earlier platforms as well.
2803 * Note that this functions assumes that 0 is
2804 * the lowest voltage value, and higher values
2805 * correspond to increasingly higher voltages.
2807 * Should that relationship no longer hold on
2808 * future platforms this code will need to be
2811 static int bxt_compute_min_voltage_level(struct intel_cdclk_state
*cdclk_state
)
2813 struct intel_atomic_state
*state
= cdclk_state
->base
.state
;
2814 struct drm_i915_private
*dev_priv
= to_i915(state
->base
.dev
);
2815 struct intel_crtc
*crtc
;
2816 struct intel_crtc_state
*crtc_state
;
2817 u8 min_voltage_level
;
2821 for_each_new_intel_crtc_in_state(state
, crtc
, crtc_state
, i
) {
2824 if (crtc_state
->hw
.enable
)
2825 min_voltage_level
= crtc_state
->min_voltage_level
;
2827 min_voltage_level
= 0;
2829 if (cdclk_state
->min_voltage_level
[crtc
->pipe
] == min_voltage_level
)
2832 cdclk_state
->min_voltage_level
[crtc
->pipe
] = min_voltage_level
;
2834 ret
= intel_atomic_lock_global_state(&cdclk_state
->base
);
2839 min_voltage_level
= 0;
2840 for_each_pipe(dev_priv
, pipe
)
2841 min_voltage_level
= max(cdclk_state
->min_voltage_level
[pipe
],
2844 return min_voltage_level
;
2847 static int vlv_modeset_calc_cdclk(struct intel_cdclk_state
*cdclk_state
)
2849 struct intel_atomic_state
*state
= cdclk_state
->base
.state
;
2850 struct drm_i915_private
*dev_priv
= to_i915(state
->base
.dev
);
2851 int min_cdclk
, cdclk
;
2853 min_cdclk
= intel_compute_min_cdclk(cdclk_state
);
2857 cdclk
= vlv_calc_cdclk(dev_priv
, min_cdclk
);
2859 cdclk_state
->logical
.cdclk
= cdclk
;
2860 cdclk_state
->logical
.voltage_level
=
2861 vlv_calc_voltage_level(dev_priv
, cdclk
);
2863 if (!cdclk_state
->active_pipes
) {
2864 cdclk
= vlv_calc_cdclk(dev_priv
, cdclk_state
->force_min_cdclk
);
2866 cdclk_state
->actual
.cdclk
= cdclk
;
2867 cdclk_state
->actual
.voltage_level
=
2868 vlv_calc_voltage_level(dev_priv
, cdclk
);
2870 cdclk_state
->actual
= cdclk_state
->logical
;
2876 static int bdw_modeset_calc_cdclk(struct intel_cdclk_state
*cdclk_state
)
2878 int min_cdclk
, cdclk
;
2880 min_cdclk
= intel_compute_min_cdclk(cdclk_state
);
2884 cdclk
= bdw_calc_cdclk(min_cdclk
);
2886 cdclk_state
->logical
.cdclk
= cdclk
;
2887 cdclk_state
->logical
.voltage_level
=
2888 bdw_calc_voltage_level(cdclk
);
2890 if (!cdclk_state
->active_pipes
) {
2891 cdclk
= bdw_calc_cdclk(cdclk_state
->force_min_cdclk
);
2893 cdclk_state
->actual
.cdclk
= cdclk
;
2894 cdclk_state
->actual
.voltage_level
=
2895 bdw_calc_voltage_level(cdclk
);
2897 cdclk_state
->actual
= cdclk_state
->logical
;
2903 static int skl_dpll0_vco(struct intel_cdclk_state
*cdclk_state
)
2905 struct intel_atomic_state
*state
= cdclk_state
->base
.state
;
2906 struct drm_i915_private
*dev_priv
= to_i915(state
->base
.dev
);
2907 struct intel_crtc
*crtc
;
2908 struct intel_crtc_state
*crtc_state
;
2911 vco
= cdclk_state
->logical
.vco
;
2913 vco
= dev_priv
->skl_preferred_vco_freq
;
2915 for_each_new_intel_crtc_in_state(state
, crtc
, crtc_state
, i
) {
2916 if (!crtc_state
->hw
.enable
)
2919 if (!intel_crtc_has_type(crtc_state
, INTEL_OUTPUT_EDP
))
2923 * DPLL0 VCO may need to be adjusted to get the correct
2924 * clock for eDP. This will affect cdclk as well.
2926 switch (crtc_state
->port_clock
/ 2) {
2940 static int skl_modeset_calc_cdclk(struct intel_cdclk_state
*cdclk_state
)
2942 int min_cdclk
, cdclk
, vco
;
2944 min_cdclk
= intel_compute_min_cdclk(cdclk_state
);
2948 vco
= skl_dpll0_vco(cdclk_state
);
2950 cdclk
= skl_calc_cdclk(min_cdclk
, vco
);
2952 cdclk_state
->logical
.vco
= vco
;
2953 cdclk_state
->logical
.cdclk
= cdclk
;
2954 cdclk_state
->logical
.voltage_level
=
2955 skl_calc_voltage_level(cdclk
);
2957 if (!cdclk_state
->active_pipes
) {
2958 cdclk
= skl_calc_cdclk(cdclk_state
->force_min_cdclk
, vco
);
2960 cdclk_state
->actual
.vco
= vco
;
2961 cdclk_state
->actual
.cdclk
= cdclk
;
2962 cdclk_state
->actual
.voltage_level
=
2963 skl_calc_voltage_level(cdclk
);
2965 cdclk_state
->actual
= cdclk_state
->logical
;
2971 static int bxt_modeset_calc_cdclk(struct intel_cdclk_state
*cdclk_state
)
2973 struct intel_atomic_state
*state
= cdclk_state
->base
.state
;
2974 struct drm_i915_private
*dev_priv
= to_i915(state
->base
.dev
);
2975 int min_cdclk
, min_voltage_level
, cdclk
, vco
;
2977 min_cdclk
= intel_compute_min_cdclk(cdclk_state
);
2981 min_voltage_level
= bxt_compute_min_voltage_level(cdclk_state
);
2982 if (min_voltage_level
< 0)
2983 return min_voltage_level
;
2985 cdclk
= bxt_calc_cdclk(dev_priv
, min_cdclk
);
2986 vco
= bxt_calc_cdclk_pll_vco(dev_priv
, cdclk
);
2988 cdclk_state
->logical
.vco
= vco
;
2989 cdclk_state
->logical
.cdclk
= cdclk
;
2990 cdclk_state
->logical
.voltage_level
=
2991 max_t(int, min_voltage_level
,
2992 intel_cdclk_calc_voltage_level(dev_priv
, cdclk
));
2994 if (!cdclk_state
->active_pipes
) {
2995 cdclk
= bxt_calc_cdclk(dev_priv
, cdclk_state
->force_min_cdclk
);
2996 vco
= bxt_calc_cdclk_pll_vco(dev_priv
, cdclk
);
2998 cdclk_state
->actual
.vco
= vco
;
2999 cdclk_state
->actual
.cdclk
= cdclk
;
3000 cdclk_state
->actual
.voltage_level
=
3001 intel_cdclk_calc_voltage_level(dev_priv
, cdclk
);
3003 cdclk_state
->actual
= cdclk_state
->logical
;
3009 static int fixed_modeset_calc_cdclk(struct intel_cdclk_state
*cdclk_state
)
3014 * We can't change the cdclk frequency, but we still want to
3015 * check that the required minimum frequency doesn't exceed
3016 * the actual cdclk frequency.
3018 min_cdclk
= intel_compute_min_cdclk(cdclk_state
);
3025 static struct intel_global_state
*intel_cdclk_duplicate_state(struct intel_global_obj
*obj
)
3027 struct intel_cdclk_state
*cdclk_state
;
3029 cdclk_state
= kmemdup(obj
->state
, sizeof(*cdclk_state
), GFP_KERNEL
);
3033 cdclk_state
->pipe
= INVALID_PIPE
;
3035 return &cdclk_state
->base
;
3038 static void intel_cdclk_destroy_state(struct intel_global_obj
*obj
,
3039 struct intel_global_state
*state
)
3044 static const struct intel_global_state_funcs intel_cdclk_funcs
= {
3045 .atomic_duplicate_state
= intel_cdclk_duplicate_state
,
3046 .atomic_destroy_state
= intel_cdclk_destroy_state
,
3049 struct intel_cdclk_state
*
3050 intel_atomic_get_cdclk_state(struct intel_atomic_state
*state
)
3052 struct drm_i915_private
*dev_priv
= to_i915(state
->base
.dev
);
3053 struct intel_global_state
*cdclk_state
;
3055 cdclk_state
= intel_atomic_get_global_obj_state(state
, &dev_priv
->display
.cdclk
.obj
);
3056 if (IS_ERR(cdclk_state
))
3057 return ERR_CAST(cdclk_state
);
3059 return to_intel_cdclk_state(cdclk_state
);
3062 int intel_cdclk_atomic_check(struct intel_atomic_state
*state
,
3063 bool *need_cdclk_calc
)
3065 const struct intel_cdclk_state
*old_cdclk_state
;
3066 const struct intel_cdclk_state
*new_cdclk_state
;
3067 struct intel_plane_state __maybe_unused
*plane_state
;
3068 struct intel_plane
*plane
;
3073 * active_planes bitmask has been updated, and potentially affected
3074 * planes are part of the state. We can now compute the minimum cdclk
3077 for_each_new_intel_plane_in_state(state
, plane
, plane_state
, i
) {
3078 ret
= intel_plane_calc_min_cdclk(state
, plane
, need_cdclk_calc
);
3083 ret
= intel_bw_calc_min_cdclk(state
, need_cdclk_calc
);
3087 old_cdclk_state
= intel_atomic_get_old_cdclk_state(state
);
3088 new_cdclk_state
= intel_atomic_get_new_cdclk_state(state
);
3090 if (new_cdclk_state
&&
3091 old_cdclk_state
->force_min_cdclk
!= new_cdclk_state
->force_min_cdclk
)
3092 *need_cdclk_calc
= true;
3097 int intel_cdclk_init(struct drm_i915_private
*dev_priv
)
3099 struct intel_cdclk_state
*cdclk_state
;
3101 cdclk_state
= kzalloc(sizeof(*cdclk_state
), GFP_KERNEL
);
3105 intel_atomic_global_obj_init(dev_priv
, &dev_priv
->display
.cdclk
.obj
,
3106 &cdclk_state
->base
, &intel_cdclk_funcs
);
3111 static bool intel_cdclk_need_serialize(struct drm_i915_private
*i915
,
3112 const struct intel_cdclk_state
*old_cdclk_state
,
3113 const struct intel_cdclk_state
*new_cdclk_state
)
3115 bool power_well_cnt_changed
= hweight8(old_cdclk_state
->active_pipes
) !=
3116 hweight8(new_cdclk_state
->active_pipes
);
3117 bool cdclk_changed
= intel_cdclk_changed(&old_cdclk_state
->actual
,
3118 &new_cdclk_state
->actual
);
3120 * We need to poke hw for gen >= 12, because we notify PCode if
3121 * pipe power well count changes.
3123 return cdclk_changed
|| (IS_DG2(i915
) && power_well_cnt_changed
);
3126 int intel_modeset_calc_cdclk(struct intel_atomic_state
*state
)
3128 struct drm_i915_private
*dev_priv
= to_i915(state
->base
.dev
);
3129 const struct intel_cdclk_state
*old_cdclk_state
;
3130 struct intel_cdclk_state
*new_cdclk_state
;
3131 enum pipe pipe
= INVALID_PIPE
;
3134 new_cdclk_state
= intel_atomic_get_cdclk_state(state
);
3135 if (IS_ERR(new_cdclk_state
))
3136 return PTR_ERR(new_cdclk_state
);
3138 old_cdclk_state
= intel_atomic_get_old_cdclk_state(state
);
3140 new_cdclk_state
->active_pipes
=
3141 intel_calc_active_pipes(state
, old_cdclk_state
->active_pipes
);
3143 ret
= intel_cdclk_modeset_calc_cdclk(dev_priv
, new_cdclk_state
);
3147 if (intel_cdclk_need_serialize(dev_priv
, old_cdclk_state
, new_cdclk_state
)) {
3149 * Also serialize commits across all crtcs
3150 * if the actual hw needs to be poked.
3152 ret
= intel_atomic_serialize_global_state(&new_cdclk_state
->base
);
3155 } else if (old_cdclk_state
->active_pipes
!= new_cdclk_state
->active_pipes
||
3156 old_cdclk_state
->force_min_cdclk
!= new_cdclk_state
->force_min_cdclk
||
3157 intel_cdclk_changed(&old_cdclk_state
->logical
,
3158 &new_cdclk_state
->logical
)) {
3159 ret
= intel_atomic_lock_global_state(&new_cdclk_state
->base
);
3166 if (is_power_of_2(new_cdclk_state
->active_pipes
) &&
3167 intel_cdclk_can_cd2x_update(dev_priv
,
3168 &old_cdclk_state
->actual
,
3169 &new_cdclk_state
->actual
)) {
3170 struct intel_crtc
*crtc
;
3171 struct intel_crtc_state
*crtc_state
;
3173 pipe
= ilog2(new_cdclk_state
->active_pipes
);
3174 crtc
= intel_crtc_for_pipe(dev_priv
, pipe
);
3176 crtc_state
= intel_atomic_get_crtc_state(&state
->base
, crtc
);
3177 if (IS_ERR(crtc_state
))
3178 return PTR_ERR(crtc_state
);
3180 if (intel_crtc_needs_modeset(crtc_state
))
3181 pipe
= INVALID_PIPE
;
3184 if (intel_cdclk_can_crawl_and_squash(dev_priv
,
3185 &old_cdclk_state
->actual
,
3186 &new_cdclk_state
->actual
)) {
3187 drm_dbg_kms(&dev_priv
->drm
,
3188 "Can change cdclk via crawling and squashing\n");
3189 } else if (intel_cdclk_can_squash(dev_priv
,
3190 &old_cdclk_state
->actual
,
3191 &new_cdclk_state
->actual
)) {
3192 drm_dbg_kms(&dev_priv
->drm
,
3193 "Can change cdclk via squashing\n");
3194 } else if (intel_cdclk_can_crawl(dev_priv
,
3195 &old_cdclk_state
->actual
,
3196 &new_cdclk_state
->actual
)) {
3197 drm_dbg_kms(&dev_priv
->drm
,
3198 "Can change cdclk via crawling\n");
3199 } else if (pipe
!= INVALID_PIPE
) {
3200 new_cdclk_state
->pipe
= pipe
;
3202 drm_dbg_kms(&dev_priv
->drm
,
3203 "Can change cdclk cd2x divider with pipe %c active\n",
3205 } else if (intel_cdclk_needs_modeset(&old_cdclk_state
->actual
,
3206 &new_cdclk_state
->actual
)) {
3207 /* All pipes must be switched off while we change the cdclk. */
3208 ret
= intel_modeset_all_pipes_late(state
, "CDCLK change");
3212 drm_dbg_kms(&dev_priv
->drm
,
3213 "Modeset required for cdclk change\n");
3216 drm_dbg_kms(&dev_priv
->drm
,
3217 "New cdclk calculated to be logical %u kHz, actual %u kHz\n",
3218 new_cdclk_state
->logical
.cdclk
,
3219 new_cdclk_state
->actual
.cdclk
);
3220 drm_dbg_kms(&dev_priv
->drm
,
3221 "New voltage level calculated to be logical %u, actual %u\n",
3222 new_cdclk_state
->logical
.voltage_level
,
3223 new_cdclk_state
->actual
.voltage_level
);
3228 static int intel_compute_max_dotclk(struct drm_i915_private
*dev_priv
)
3230 int max_cdclk_freq
= dev_priv
->display
.cdclk
.max_cdclk_freq
;
3232 if (DISPLAY_VER(dev_priv
) >= 10)
3233 return 2 * max_cdclk_freq
;
3234 else if (DISPLAY_VER(dev_priv
) == 9 ||
3235 IS_BROADWELL(dev_priv
) || IS_HASWELL(dev_priv
))
3236 return max_cdclk_freq
;
3237 else if (IS_CHERRYVIEW(dev_priv
))
3238 return max_cdclk_freq
*95/100;
3239 else if (DISPLAY_VER(dev_priv
) < 4)
3240 return 2*max_cdclk_freq
*90/100;
3242 return max_cdclk_freq
*90/100;
3246 * intel_update_max_cdclk - Determine the maximum support CDCLK frequency
3247 * @dev_priv: i915 device
3249 * Determine the maximum CDCLK frequency the platform supports, and also
3250 * derive the maximum dot clock frequency the maximum CDCLK frequency
3253 void intel_update_max_cdclk(struct drm_i915_private
*dev_priv
)
3255 if (IS_JASPERLAKE(dev_priv
) || IS_ELKHARTLAKE(dev_priv
)) {
3256 if (dev_priv
->display
.cdclk
.hw
.ref
== 24000)
3257 dev_priv
->display
.cdclk
.max_cdclk_freq
= 552000;
3259 dev_priv
->display
.cdclk
.max_cdclk_freq
= 556800;
3260 } else if (DISPLAY_VER(dev_priv
) >= 11) {
3261 if (dev_priv
->display
.cdclk
.hw
.ref
== 24000)
3262 dev_priv
->display
.cdclk
.max_cdclk_freq
= 648000;
3264 dev_priv
->display
.cdclk
.max_cdclk_freq
= 652800;
3265 } else if (IS_GEMINILAKE(dev_priv
)) {
3266 dev_priv
->display
.cdclk
.max_cdclk_freq
= 316800;
3267 } else if (IS_BROXTON(dev_priv
)) {
3268 dev_priv
->display
.cdclk
.max_cdclk_freq
= 624000;
3269 } else if (DISPLAY_VER(dev_priv
) == 9) {
3270 u32 limit
= intel_de_read(dev_priv
, SKL_DFSM
) & SKL_DFSM_CDCLK_LIMIT_MASK
;
3273 vco
= dev_priv
->skl_preferred_vco_freq
;
3274 drm_WARN_ON(&dev_priv
->drm
, vco
!= 8100000 && vco
!= 8640000);
3277 * Use the lower (vco 8640) cdclk values as a
3278 * first guess. skl_calc_cdclk() will correct it
3279 * if the preferred vco is 8100 instead.
3281 if (limit
== SKL_DFSM_CDCLK_LIMIT_675
)
3283 else if (limit
== SKL_DFSM_CDCLK_LIMIT_540
)
3285 else if (limit
== SKL_DFSM_CDCLK_LIMIT_450
)
3290 dev_priv
->display
.cdclk
.max_cdclk_freq
= skl_calc_cdclk(max_cdclk
, vco
);
3291 } else if (IS_BROADWELL(dev_priv
)) {
3293 * FIXME with extra cooling we can allow
3294 * 540 MHz for ULX and 675 Mhz for ULT.
3295 * How can we know if extra cooling is
3296 * available? PCI ID, VTB, something else?
3298 if (intel_de_read(dev_priv
, FUSE_STRAP
) & HSW_CDCLK_LIMIT
)
3299 dev_priv
->display
.cdclk
.max_cdclk_freq
= 450000;
3300 else if (IS_BROADWELL_ULX(dev_priv
))
3301 dev_priv
->display
.cdclk
.max_cdclk_freq
= 450000;
3302 else if (IS_BROADWELL_ULT(dev_priv
))
3303 dev_priv
->display
.cdclk
.max_cdclk_freq
= 540000;
3305 dev_priv
->display
.cdclk
.max_cdclk_freq
= 675000;
3306 } else if (IS_CHERRYVIEW(dev_priv
)) {
3307 dev_priv
->display
.cdclk
.max_cdclk_freq
= 320000;
3308 } else if (IS_VALLEYVIEW(dev_priv
)) {
3309 dev_priv
->display
.cdclk
.max_cdclk_freq
= 400000;
3311 /* otherwise assume cdclk is fixed */
3312 dev_priv
->display
.cdclk
.max_cdclk_freq
= dev_priv
->display
.cdclk
.hw
.cdclk
;
3315 dev_priv
->max_dotclk_freq
= intel_compute_max_dotclk(dev_priv
);
3317 drm_dbg(&dev_priv
->drm
, "Max CD clock rate: %d kHz\n",
3318 dev_priv
->display
.cdclk
.max_cdclk_freq
);
3320 drm_dbg(&dev_priv
->drm
, "Max dotclock rate: %d kHz\n",
3321 dev_priv
->max_dotclk_freq
);
3325 * intel_update_cdclk - Determine the current CDCLK frequency
3326 * @dev_priv: i915 device
3328 * Determine the current CDCLK frequency.
3330 void intel_update_cdclk(struct drm_i915_private
*dev_priv
)
3332 intel_cdclk_get_cdclk(dev_priv
, &dev_priv
->display
.cdclk
.hw
);
3335 * 9:0 CMBUS [sic] CDCLK frequency (cdfreq):
3336 * Programmng [sic] note: bit[9:2] should be programmed to the number
3337 * of cdclk that generates 4MHz reference clock freq which is used to
3338 * generate GMBus clock. This will vary with the cdclk freq.
3340 if (IS_VALLEYVIEW(dev_priv
) || IS_CHERRYVIEW(dev_priv
))
3341 intel_de_write(dev_priv
, GMBUSFREQ_VLV
,
3342 DIV_ROUND_UP(dev_priv
->display
.cdclk
.hw
.cdclk
, 1000));
3345 static int dg1_rawclk(struct drm_i915_private
*dev_priv
)
3348 * DG1 always uses a 38.4 MHz rawclk. The bspec tells us
3349 * "Program Numerator=2, Denominator=4, Divider=37 decimal."
3351 intel_de_write(dev_priv
, PCH_RAWCLK_FREQ
,
3352 CNP_RAWCLK_DEN(4) | CNP_RAWCLK_DIV(37) | ICP_RAWCLK_NUM(2));
3357 static int cnp_rawclk(struct drm_i915_private
*dev_priv
)
3360 int divider
, fraction
;
3362 if (intel_de_read(dev_priv
, SFUSE_STRAP
) & SFUSE_STRAP_RAW_FREQUENCY
) {
3372 rawclk
= CNP_RAWCLK_DIV(divider
/ 1000);
3376 rawclk
|= CNP_RAWCLK_DEN(DIV_ROUND_CLOSEST(numerator
* 1000,
3378 if (INTEL_PCH_TYPE(dev_priv
) >= PCH_ICP
)
3379 rawclk
|= ICP_RAWCLK_NUM(numerator
);
3382 intel_de_write(dev_priv
, PCH_RAWCLK_FREQ
, rawclk
);
3383 return divider
+ fraction
;
3386 static int pch_rawclk(struct drm_i915_private
*dev_priv
)
3388 return (intel_de_read(dev_priv
, PCH_RAWCLK_FREQ
) & RAWCLK_FREQ_MASK
) * 1000;
3391 static int vlv_hrawclk(struct drm_i915_private
*dev_priv
)
3393 /* RAWCLK_FREQ_VLV register updated from power well code */
3394 return vlv_get_cck_clock_hpll(dev_priv
, "hrawclk",
3395 CCK_DISPLAY_REF_CLOCK_CONTROL
);
3398 static int i9xx_hrawclk(struct drm_i915_private
*dev_priv
)
3403 * hrawclock is 1/4 the FSB frequency
3405 * Note that this only reads the state of the FSB
3406 * straps, not the actual FSB frequency. Some BIOSen
3407 * let you configure each independently. Ideally we'd
3408 * read out the actual FSB frequency but sadly we
3409 * don't know which registers have that information,
3410 * and all the relevant docs have gone to bit heaven :(
3412 clkcfg
= intel_de_read(dev_priv
, CLKCFG
) & CLKCFG_FSB_MASK
;
3414 if (IS_MOBILE(dev_priv
)) {
3416 case CLKCFG_FSB_400
:
3418 case CLKCFG_FSB_533
:
3420 case CLKCFG_FSB_667
:
3422 case CLKCFG_FSB_800
:
3424 case CLKCFG_FSB_1067
:
3426 case CLKCFG_FSB_1333
:
3429 MISSING_CASE(clkcfg
);
3434 case CLKCFG_FSB_400_ALT
:
3436 case CLKCFG_FSB_533
:
3438 case CLKCFG_FSB_667
:
3440 case CLKCFG_FSB_800
:
3442 case CLKCFG_FSB_1067_ALT
:
3444 case CLKCFG_FSB_1333_ALT
:
3446 case CLKCFG_FSB_1600_ALT
:
3455 * intel_read_rawclk - Determine the current RAWCLK frequency
3456 * @dev_priv: i915 device
3458 * Determine the current RAWCLK frequency. RAWCLK is a fixed
3459 * frequency clock so this needs to done only once.
3461 u32
intel_read_rawclk(struct drm_i915_private
*dev_priv
)
3465 if (INTEL_PCH_TYPE(dev_priv
) >= PCH_MTL
)
3467 * MTL always uses a 38.4 MHz rawclk. The bspec tells us
3468 * "RAWCLK_FREQ defaults to the values for 38.4 and does
3469 * not need to be programmed."
3472 else if (INTEL_PCH_TYPE(dev_priv
) >= PCH_DG1
)
3473 freq
= dg1_rawclk(dev_priv
);
3474 else if (INTEL_PCH_TYPE(dev_priv
) >= PCH_CNP
)
3475 freq
= cnp_rawclk(dev_priv
);
3476 else if (HAS_PCH_SPLIT(dev_priv
))
3477 freq
= pch_rawclk(dev_priv
);
3478 else if (IS_VALLEYVIEW(dev_priv
) || IS_CHERRYVIEW(dev_priv
))
3479 freq
= vlv_hrawclk(dev_priv
);
3480 else if (DISPLAY_VER(dev_priv
) >= 3)
3481 freq
= i9xx_hrawclk(dev_priv
);
3483 /* no rawclk on other platforms, or no need to know it */
3489 static int i915_cdclk_info_show(struct seq_file
*m
, void *unused
)
3491 struct drm_i915_private
*i915
= m
->private;
3493 seq_printf(m
, "Current CD clock frequency: %d kHz\n", i915
->display
.cdclk
.hw
.cdclk
);
3494 seq_printf(m
, "Max CD clock frequency: %d kHz\n", i915
->display
.cdclk
.max_cdclk_freq
);
3495 seq_printf(m
, "Max pixel clock frequency: %d kHz\n", i915
->max_dotclk_freq
);
3500 DEFINE_SHOW_ATTRIBUTE(i915_cdclk_info
);
3502 void intel_cdclk_debugfs_register(struct drm_i915_private
*i915
)
3504 struct drm_minor
*minor
= i915
->drm
.primary
;
3506 debugfs_create_file("i915_cdclk_info", 0444, minor
->debugfs_root
,
3507 i915
, &i915_cdclk_info_fops
);
3510 static const struct intel_cdclk_funcs mtl_cdclk_funcs
= {
3511 .get_cdclk
= bxt_get_cdclk
,
3512 .set_cdclk
= bxt_set_cdclk
,
3513 .modeset_calc_cdclk
= bxt_modeset_calc_cdclk
,
3514 .calc_voltage_level
= rplu_calc_voltage_level
,
3517 static const struct intel_cdclk_funcs rplu_cdclk_funcs
= {
3518 .get_cdclk
= bxt_get_cdclk
,
3519 .set_cdclk
= bxt_set_cdclk
,
3520 .modeset_calc_cdclk
= bxt_modeset_calc_cdclk
,
3521 .calc_voltage_level
= rplu_calc_voltage_level
,
3524 static const struct intel_cdclk_funcs tgl_cdclk_funcs
= {
3525 .get_cdclk
= bxt_get_cdclk
,
3526 .set_cdclk
= bxt_set_cdclk
,
3527 .modeset_calc_cdclk
= bxt_modeset_calc_cdclk
,
3528 .calc_voltage_level
= tgl_calc_voltage_level
,
3531 static const struct intel_cdclk_funcs ehl_cdclk_funcs
= {
3532 .get_cdclk
= bxt_get_cdclk
,
3533 .set_cdclk
= bxt_set_cdclk
,
3534 .modeset_calc_cdclk
= bxt_modeset_calc_cdclk
,
3535 .calc_voltage_level
= ehl_calc_voltage_level
,
3538 static const struct intel_cdclk_funcs icl_cdclk_funcs
= {
3539 .get_cdclk
= bxt_get_cdclk
,
3540 .set_cdclk
= bxt_set_cdclk
,
3541 .modeset_calc_cdclk
= bxt_modeset_calc_cdclk
,
3542 .calc_voltage_level
= icl_calc_voltage_level
,
3545 static const struct intel_cdclk_funcs bxt_cdclk_funcs
= {
3546 .get_cdclk
= bxt_get_cdclk
,
3547 .set_cdclk
= bxt_set_cdclk
,
3548 .modeset_calc_cdclk
= bxt_modeset_calc_cdclk
,
3549 .calc_voltage_level
= bxt_calc_voltage_level
,
3552 static const struct intel_cdclk_funcs skl_cdclk_funcs
= {
3553 .get_cdclk
= skl_get_cdclk
,
3554 .set_cdclk
= skl_set_cdclk
,
3555 .modeset_calc_cdclk
= skl_modeset_calc_cdclk
,
3558 static const struct intel_cdclk_funcs bdw_cdclk_funcs
= {
3559 .get_cdclk
= bdw_get_cdclk
,
3560 .set_cdclk
= bdw_set_cdclk
,
3561 .modeset_calc_cdclk
= bdw_modeset_calc_cdclk
,
3564 static const struct intel_cdclk_funcs chv_cdclk_funcs
= {
3565 .get_cdclk
= vlv_get_cdclk
,
3566 .set_cdclk
= chv_set_cdclk
,
3567 .modeset_calc_cdclk
= vlv_modeset_calc_cdclk
,
3570 static const struct intel_cdclk_funcs vlv_cdclk_funcs
= {
3571 .get_cdclk
= vlv_get_cdclk
,
3572 .set_cdclk
= vlv_set_cdclk
,
3573 .modeset_calc_cdclk
= vlv_modeset_calc_cdclk
,
3576 static const struct intel_cdclk_funcs hsw_cdclk_funcs
= {
3577 .get_cdclk
= hsw_get_cdclk
,
3578 .modeset_calc_cdclk
= fixed_modeset_calc_cdclk
,
3581 /* SNB, IVB, 965G, 945G */
3582 static const struct intel_cdclk_funcs fixed_400mhz_cdclk_funcs
= {
3583 .get_cdclk
= fixed_400mhz_get_cdclk
,
3584 .modeset_calc_cdclk
= fixed_modeset_calc_cdclk
,
3587 static const struct intel_cdclk_funcs ilk_cdclk_funcs
= {
3588 .get_cdclk
= fixed_450mhz_get_cdclk
,
3589 .modeset_calc_cdclk
= fixed_modeset_calc_cdclk
,
3592 static const struct intel_cdclk_funcs gm45_cdclk_funcs
= {
3593 .get_cdclk
= gm45_get_cdclk
,
3594 .modeset_calc_cdclk
= fixed_modeset_calc_cdclk
,
3599 static const struct intel_cdclk_funcs i965gm_cdclk_funcs
= {
3600 .get_cdclk
= i965gm_get_cdclk
,
3601 .modeset_calc_cdclk
= fixed_modeset_calc_cdclk
,
3604 /* i965G uses fixed 400 */
3606 static const struct intel_cdclk_funcs pnv_cdclk_funcs
= {
3607 .get_cdclk
= pnv_get_cdclk
,
3608 .modeset_calc_cdclk
= fixed_modeset_calc_cdclk
,
3611 static const struct intel_cdclk_funcs g33_cdclk_funcs
= {
3612 .get_cdclk
= g33_get_cdclk
,
3613 .modeset_calc_cdclk
= fixed_modeset_calc_cdclk
,
3616 static const struct intel_cdclk_funcs i945gm_cdclk_funcs
= {
3617 .get_cdclk
= i945gm_get_cdclk
,
3618 .modeset_calc_cdclk
= fixed_modeset_calc_cdclk
,
3621 /* i945G uses fixed 400 */
3623 static const struct intel_cdclk_funcs i915gm_cdclk_funcs
= {
3624 .get_cdclk
= i915gm_get_cdclk
,
3625 .modeset_calc_cdclk
= fixed_modeset_calc_cdclk
,
3628 static const struct intel_cdclk_funcs i915g_cdclk_funcs
= {
3629 .get_cdclk
= fixed_333mhz_get_cdclk
,
3630 .modeset_calc_cdclk
= fixed_modeset_calc_cdclk
,
3633 static const struct intel_cdclk_funcs i865g_cdclk_funcs
= {
3634 .get_cdclk
= fixed_266mhz_get_cdclk
,
3635 .modeset_calc_cdclk
= fixed_modeset_calc_cdclk
,
3638 static const struct intel_cdclk_funcs i85x_cdclk_funcs
= {
3639 .get_cdclk
= i85x_get_cdclk
,
3640 .modeset_calc_cdclk
= fixed_modeset_calc_cdclk
,
3643 static const struct intel_cdclk_funcs i845g_cdclk_funcs
= {
3644 .get_cdclk
= fixed_200mhz_get_cdclk
,
3645 .modeset_calc_cdclk
= fixed_modeset_calc_cdclk
,
3648 static const struct intel_cdclk_funcs i830_cdclk_funcs
= {
3649 .get_cdclk
= fixed_133mhz_get_cdclk
,
3650 .modeset_calc_cdclk
= fixed_modeset_calc_cdclk
,
3654 * intel_init_cdclk_hooks - Initialize CDCLK related modesetting hooks
3655 * @dev_priv: i915 device
3657 void intel_init_cdclk_hooks(struct drm_i915_private
*dev_priv
)
3659 if (DISPLAY_VER(dev_priv
) >= 20) {
3660 dev_priv
->display
.funcs
.cdclk
= &mtl_cdclk_funcs
;
3661 dev_priv
->display
.cdclk
.table
= lnl_cdclk_table
;
3662 } else if (DISPLAY_VER(dev_priv
) >= 14) {
3663 dev_priv
->display
.funcs
.cdclk
= &mtl_cdclk_funcs
;
3664 dev_priv
->display
.cdclk
.table
= mtl_cdclk_table
;
3665 } else if (IS_DG2(dev_priv
)) {
3666 dev_priv
->display
.funcs
.cdclk
= &tgl_cdclk_funcs
;
3667 dev_priv
->display
.cdclk
.table
= dg2_cdclk_table
;
3668 } else if (IS_ALDERLAKE_P(dev_priv
)) {
3669 /* Wa_22011320316:adl-p[a0] */
3670 if (IS_ALDERLAKE_P(dev_priv
) && IS_DISPLAY_STEP(dev_priv
, STEP_A0
, STEP_B0
)) {
3671 dev_priv
->display
.cdclk
.table
= adlp_a_step_cdclk_table
;
3672 dev_priv
->display
.funcs
.cdclk
= &tgl_cdclk_funcs
;
3673 } else if (IS_RAPTORLAKE_U(dev_priv
)) {
3674 dev_priv
->display
.cdclk
.table
= rplu_cdclk_table
;
3675 dev_priv
->display
.funcs
.cdclk
= &rplu_cdclk_funcs
;
3677 dev_priv
->display
.cdclk
.table
= adlp_cdclk_table
;
3678 dev_priv
->display
.funcs
.cdclk
= &tgl_cdclk_funcs
;
3680 } else if (IS_ROCKETLAKE(dev_priv
)) {
3681 dev_priv
->display
.funcs
.cdclk
= &tgl_cdclk_funcs
;
3682 dev_priv
->display
.cdclk
.table
= rkl_cdclk_table
;
3683 } else if (DISPLAY_VER(dev_priv
) >= 12) {
3684 dev_priv
->display
.funcs
.cdclk
= &tgl_cdclk_funcs
;
3685 dev_priv
->display
.cdclk
.table
= icl_cdclk_table
;
3686 } else if (IS_JASPERLAKE(dev_priv
) || IS_ELKHARTLAKE(dev_priv
)) {
3687 dev_priv
->display
.funcs
.cdclk
= &ehl_cdclk_funcs
;
3688 dev_priv
->display
.cdclk
.table
= icl_cdclk_table
;
3689 } else if (DISPLAY_VER(dev_priv
) >= 11) {
3690 dev_priv
->display
.funcs
.cdclk
= &icl_cdclk_funcs
;
3691 dev_priv
->display
.cdclk
.table
= icl_cdclk_table
;
3692 } else if (IS_GEMINILAKE(dev_priv
) || IS_BROXTON(dev_priv
)) {
3693 dev_priv
->display
.funcs
.cdclk
= &bxt_cdclk_funcs
;
3694 if (IS_GEMINILAKE(dev_priv
))
3695 dev_priv
->display
.cdclk
.table
= glk_cdclk_table
;
3697 dev_priv
->display
.cdclk
.table
= bxt_cdclk_table
;
3698 } else if (DISPLAY_VER(dev_priv
) == 9) {
3699 dev_priv
->display
.funcs
.cdclk
= &skl_cdclk_funcs
;
3700 } else if (IS_BROADWELL(dev_priv
)) {
3701 dev_priv
->display
.funcs
.cdclk
= &bdw_cdclk_funcs
;
3702 } else if (IS_HASWELL(dev_priv
)) {
3703 dev_priv
->display
.funcs
.cdclk
= &hsw_cdclk_funcs
;
3704 } else if (IS_CHERRYVIEW(dev_priv
)) {
3705 dev_priv
->display
.funcs
.cdclk
= &chv_cdclk_funcs
;
3706 } else if (IS_VALLEYVIEW(dev_priv
)) {
3707 dev_priv
->display
.funcs
.cdclk
= &vlv_cdclk_funcs
;
3708 } else if (IS_SANDYBRIDGE(dev_priv
) || IS_IVYBRIDGE(dev_priv
)) {
3709 dev_priv
->display
.funcs
.cdclk
= &fixed_400mhz_cdclk_funcs
;
3710 } else if (IS_IRONLAKE(dev_priv
)) {
3711 dev_priv
->display
.funcs
.cdclk
= &ilk_cdclk_funcs
;
3712 } else if (IS_GM45(dev_priv
)) {
3713 dev_priv
->display
.funcs
.cdclk
= &gm45_cdclk_funcs
;
3714 } else if (IS_G45(dev_priv
)) {
3715 dev_priv
->display
.funcs
.cdclk
= &g33_cdclk_funcs
;
3716 } else if (IS_I965GM(dev_priv
)) {
3717 dev_priv
->display
.funcs
.cdclk
= &i965gm_cdclk_funcs
;
3718 } else if (IS_I965G(dev_priv
)) {
3719 dev_priv
->display
.funcs
.cdclk
= &fixed_400mhz_cdclk_funcs
;
3720 } else if (IS_PINEVIEW(dev_priv
)) {
3721 dev_priv
->display
.funcs
.cdclk
= &pnv_cdclk_funcs
;
3722 } else if (IS_G33(dev_priv
)) {
3723 dev_priv
->display
.funcs
.cdclk
= &g33_cdclk_funcs
;
3724 } else if (IS_I945GM(dev_priv
)) {
3725 dev_priv
->display
.funcs
.cdclk
= &i945gm_cdclk_funcs
;
3726 } else if (IS_I945G(dev_priv
)) {
3727 dev_priv
->display
.funcs
.cdclk
= &fixed_400mhz_cdclk_funcs
;
3728 } else if (IS_I915GM(dev_priv
)) {
3729 dev_priv
->display
.funcs
.cdclk
= &i915gm_cdclk_funcs
;
3730 } else if (IS_I915G(dev_priv
)) {
3731 dev_priv
->display
.funcs
.cdclk
= &i915g_cdclk_funcs
;
3732 } else if (IS_I865G(dev_priv
)) {
3733 dev_priv
->display
.funcs
.cdclk
= &i865g_cdclk_funcs
;
3734 } else if (IS_I85X(dev_priv
)) {
3735 dev_priv
->display
.funcs
.cdclk
= &i85x_cdclk_funcs
;
3736 } else if (IS_I845G(dev_priv
)) {
3737 dev_priv
->display
.funcs
.cdclk
= &i845g_cdclk_funcs
;
3738 } else if (IS_I830(dev_priv
)) {
3739 dev_priv
->display
.funcs
.cdclk
= &i830_cdclk_funcs
;
3742 if (drm_WARN(&dev_priv
->drm
, !dev_priv
->display
.funcs
.cdclk
,
3743 "Unknown platform. Assuming i830\n"))
3744 dev_priv
->display
.funcs
.cdclk
= &i830_cdclk_funcs
;