cnl_cdclk_pll_enable(dev_priv, vco);
 
        val = divider | skl_cdclk_decimal(cdclk);
-       if (pipe == INVALID_PIPE)
-               val |= BXT_CDCLK_CD2X_PIPE_NONE;
-       else
-               val |= BXT_CDCLK_CD2X_PIPE(pipe);
+
+       if (INTEL_GEN(dev_priv) >= 12) {
+               if (pipe == INVALID_PIPE)
+                       val |= TGL_CDCLK_CD2X_PIPE_NONE;
+               else
+                       val |= TGL_CDCLK_CD2X_PIPE(pipe);
+       } else if (INTEL_GEN(dev_priv) >= 11) {
+               if (pipe == INVALID_PIPE)
+                       val |= ICL_CDCLK_CD2X_PIPE_NONE;
+               else
+                       val |= ICL_CDCLK_CD2X_PIPE(pipe);
+       } else {
+               if (pipe == INVALID_PIPE)
+                       val |= BXT_CDCLK_CD2X_PIPE_NONE;
+               else
+                       val |= BXT_CDCLK_CD2X_PIPE(pipe);
+       }
        I915_WRITE(CDCLK_CTL, val);
 
        if (pipe != INVALID_PIPE)
        return dev_priv->cdclk.hw.ref * ratio;
 }
 
-static void icl_set_cdclk(struct drm_i915_private *dev_priv,
-                         const struct intel_cdclk_state *cdclk_state,
-                         enum pipe pipe)
-{
-       unsigned int cdclk = cdclk_state->cdclk;
-       unsigned int vco = cdclk_state->vco;
-       int ret;
-
-       ret = skl_pcode_request(dev_priv, SKL_PCODE_CDCLK_CONTROL,
-                               SKL_CDCLK_PREPARE_FOR_CHANGE,
-                               SKL_CDCLK_READY_FOR_CHANGE,
-                               SKL_CDCLK_READY_FOR_CHANGE, 3);
-       if (ret) {
-               DRM_ERROR("Failed to inform PCU about cdclk change (%d)\n",
-                         ret);
-               return;
-       }
-
-       if (dev_priv->cdclk.hw.vco != 0 &&
-           dev_priv->cdclk.hw.vco != vco)
-               cnl_cdclk_pll_disable(dev_priv);
-
-       if (dev_priv->cdclk.hw.vco != vco)
-               cnl_cdclk_pll_enable(dev_priv, vco);
-
-       /*
-        * On ICL CD2X_DIV can only be 1, so we'll never end up changing the
-        * divider here synchronized to a pipe while CDCLK is on, nor will we
-        * need the corresponding vblank wait.
-        */
-       I915_WRITE(CDCLK_CTL, ICL_CDCLK_CD2X_PIPE_NONE |
-                             skl_cdclk_decimal(cdclk));
-
-       sandybridge_pcode_write(dev_priv, SKL_PCODE_CDCLK_CONTROL,
-                               cdclk_state->voltage_level);
-
-       intel_update_cdclk(dev_priv);
-
-       /*
-        * Can't read out the voltage level :(
-        * Let's just assume everything is as expected.
-        */
-       dev_priv->cdclk.hw.voltage_level = cdclk_state->voltage_level;
-}
-
 static u8 icl_calc_voltage_level(struct drm_i915_private *dev_priv, int cdclk)
 {
        if (IS_ELKHARTLAKE(dev_priv)) {
                          struct intel_cdclk_state *cdclk_state)
 {
        u32 val;
+       int div;
 
        cdclk_state->bypass = 50000;
 
 
        cdclk_state->vco = (val & BXT_DE_PLL_RATIO_MASK) * cdclk_state->ref;
 
-       val = I915_READ(CDCLK_CTL);
-       WARN_ON((val & BXT_CDCLK_CD2X_DIV_SEL_MASK) != 0);
+       val = I915_READ(CDCLK_CTL) & BXT_CDCLK_CD2X_DIV_SEL_MASK;
+       switch (val) {
+       case BXT_CDCLK_CD2X_DIV_SEL_1:
+               div = 2;
+               break;
+       case BXT_CDCLK_CD2X_DIV_SEL_2:
+               div = 4;
+               break;
+       default:
+               MISSING_CASE(val);
+               div = 2;
+               break;
+       }
 
-       cdclk_state->cdclk = cdclk_state->vco / 2;
+       cdclk_state->cdclk = DIV_ROUND_CLOSEST(cdclk_state->vco, div);
 
 out:
        /*
                                icl_calc_voltage_level(dev_priv,
                                                       sanitized_state.cdclk);
 
-       icl_set_cdclk(dev_priv, &sanitized_state, INVALID_PIPE);
+       cnl_set_cdclk(dev_priv, &sanitized_state, INVALID_PIPE);
 }
 
 static void icl_uninit_cdclk(struct drm_i915_private *dev_priv)
        cdclk_state.voltage_level = icl_calc_voltage_level(dev_priv,
                                                           cdclk_state.cdclk);
 
-       icl_set_cdclk(dev_priv, &cdclk_state, INVALID_PIPE);
+       cnl_set_cdclk(dev_priv, &cdclk_state, INVALID_PIPE);
 }
 
 static void cnl_init_cdclk(struct drm_i915_private *dev_priv)
 void intel_init_cdclk_hooks(struct drm_i915_private *dev_priv)
 {
        if (INTEL_GEN(dev_priv) >= 11) {
-               dev_priv->display.set_cdclk = icl_set_cdclk;
+               dev_priv->display.set_cdclk = cnl_set_cdclk;
                dev_priv->display.modeset_calc_cdclk = icl_modeset_calc_cdclk;
        } else if (IS_CANNONLAKE(dev_priv)) {
                dev_priv->display.set_cdclk = cnl_set_cdclk;