// SPDX-License-Identifier: MIT
/*
 * Copyright © 2020 Intel Corporation
 *
 */

#include <drm/drm_print.h>

#include "intel_de.h"
#include "intel_display_regs.h"
#include "intel_display_types.h"
#include "intel_dp.h"
#include "intel_vrr.h"
#include "intel_vrr_regs.h"

#define FIXED_POINT_PRECISION           100
#define CMRR_PRECISION_TOLERANCE        10

bool intel_vrr_is_capable(struct intel_connector *connector)
{
        struct intel_display *display = to_intel_display(connector);
        const struct drm_display_info *info = &connector->base.display_info;
        struct intel_dp *intel_dp;

        /*
         * DP Sink is capable of VRR video timings if
         * Ignore MSA bit is set in DPCD.
         * EDID monitor range also should be atleast 10 for reasonable
         * Adaptive Sync or Variable Refresh Rate end user experience.
         */
        switch (connector->base.connector_type) {
        case DRM_MODE_CONNECTOR_eDP:
                if (!connector->panel.vbt.vrr)
                        return false;
                fallthrough;
        case DRM_MODE_CONNECTOR_DisplayPort:
                if (connector->mst.dp)
                        return false;
                intel_dp = intel_attached_dp(connector);

                if (!drm_dp_sink_can_do_video_without_timing_msa(intel_dp->dpcd))
                        return false;

                break;
        default:
                return false;
        }

        return HAS_VRR(display) &&
                info->monitor_range.max_vfreq - info->monitor_range.min_vfreq > 10;
}

bool intel_vrr_is_in_range(struct intel_connector *connector, int vrefresh)
{
        const struct drm_display_info *info = &connector->base.display_info;

        return intel_vrr_is_capable(connector) &&
                vrefresh >= info->monitor_range.min_vfreq &&
                vrefresh <= info->monitor_range.max_vfreq;
}

bool intel_vrr_possible(const struct intel_crtc_state *crtc_state)
{
        return crtc_state->vrr.flipline;
}

void
intel_vrr_check_modeset(struct intel_atomic_state *state)
{
        int i;
        struct intel_crtc_state *old_crtc_state, *new_crtc_state;
        struct intel_crtc *crtc;

        for_each_oldnew_intel_crtc_in_state(state, crtc, old_crtc_state,
                                            new_crtc_state, i) {
                if (new_crtc_state->uapi.vrr_enabled !=
                    old_crtc_state->uapi.vrr_enabled)
                        new_crtc_state->uapi.mode_changed = true;
        }
}

static int intel_vrr_real_vblank_delay(const struct intel_crtc_state *crtc_state)
{
        return crtc_state->hw.adjusted_mode.crtc_vblank_start -
                crtc_state->hw.adjusted_mode.crtc_vdisplay;
}

static int intel_vrr_extra_vblank_delay(struct intel_display *display)
{
        /*
         * On ICL/TGL VRR hardware inserts one extra scanline
         * just after vactive, which pushes the vmin decision
         * boundary ahead accordingly. We'll include the extra
         * scanline in our vblank delay estimates to make sure
         * that we never underestimate how long we have until
         * the delayed vblank has passed.
         */
        return DISPLAY_VER(display) < 13 ? 1 : 0;
}

int intel_vrr_vblank_delay(const struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);

        return intel_vrr_real_vblank_delay(crtc_state) +
                intel_vrr_extra_vblank_delay(display);
}

static int intel_vrr_flipline_offset(struct intel_display *display)
{
        /* ICL/TGL hardware imposes flipline>=vmin+1 */
        return DISPLAY_VER(display) < 13 ? 1 : 0;
}

static int intel_vrr_vmin_flipline(const struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);

        return crtc_state->vrr.vmin + intel_vrr_flipline_offset(display);
}

/*
 * Without VRR registers get latched at:
 *  vblank_start
 *
 * With VRR the earliest registers can get latched is:
 *  intel_vrr_vmin_vblank_start(), which if we want to maintain
 *  the correct min vtotal is >=vblank_start+1
 *
 * The latest point registers can get latched is the vmax decision boundary:
 *  intel_vrr_vmax_vblank_start()
 *
 * Between those two points the vblank exit starts (and hence registers get
 * latched) ASAP after a push is sent.
 *
 * framestart_delay is programmable 1-4.
 */
static int intel_vrr_vblank_exit_length(const struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);

        if (DISPLAY_VER(display) >= 13)
                return crtc_state->vrr.guardband;
        else
                /* hardware imposes one extra scanline somewhere */
                return crtc_state->vrr.pipeline_full + crtc_state->framestart_delay + 1;
}

int intel_vrr_vmin_vtotal(const struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);

        /* Min vblank actually determined by flipline */
        if (DISPLAY_VER(display) >= 13)
                return intel_vrr_vmin_flipline(crtc_state);
        else
                return intel_vrr_vmin_flipline(crtc_state) +
                        intel_vrr_real_vblank_delay(crtc_state);
}

int intel_vrr_vmax_vtotal(const struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);

        if (DISPLAY_VER(display) >= 13)
                return crtc_state->vrr.vmax;
        else
                return crtc_state->vrr.vmax +
                        intel_vrr_real_vblank_delay(crtc_state);
}

int intel_vrr_vmin_vblank_start(const struct intel_crtc_state *crtc_state)
{
        return intel_vrr_vmin_vtotal(crtc_state) - intel_vrr_vblank_exit_length(crtc_state);
}

int intel_vrr_vmax_vblank_start(const struct intel_crtc_state *crtc_state)
{
        return intel_vrr_vmax_vtotal(crtc_state) - intel_vrr_vblank_exit_length(crtc_state);
}

static bool
is_cmrr_frac_required(struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);
        int calculated_refresh_k, actual_refresh_k, pixel_clock_per_line;
        struct drm_display_mode *adjusted_mode = &crtc_state->hw.adjusted_mode;

        /* Avoid CMRR for now till we have VRR with fixed timings working */
        if (!HAS_CMRR(display) || true)
                return false;

        actual_refresh_k =
                drm_mode_vrefresh(adjusted_mode) * FIXED_POINT_PRECISION;
        pixel_clock_per_line =
                adjusted_mode->crtc_clock * 1000 / adjusted_mode->crtc_htotal;
        calculated_refresh_k =
                pixel_clock_per_line * FIXED_POINT_PRECISION / adjusted_mode->crtc_vtotal;

        if ((actual_refresh_k - calculated_refresh_k) < CMRR_PRECISION_TOLERANCE)
                return false;

        return true;
}

static unsigned int
cmrr_get_vtotal(struct intel_crtc_state *crtc_state, bool video_mode_required)
{
        int multiplier_m = 1, multiplier_n = 1, vtotal, desired_refresh_rate;
        u64 adjusted_pixel_rate;
        struct drm_display_mode *adjusted_mode = &crtc_state->hw.adjusted_mode;

        desired_refresh_rate = drm_mode_vrefresh(adjusted_mode);

        if (video_mode_required) {
                multiplier_m = 1001;
                multiplier_n = 1000;
        }

        crtc_state->cmrr.cmrr_n = mul_u32_u32(desired_refresh_rate * adjusted_mode->crtc_htotal,
                                              multiplier_n);
        vtotal = DIV_ROUND_UP_ULL(mul_u32_u32(adjusted_mode->crtc_clock * 1000, multiplier_n),
                                  crtc_state->cmrr.cmrr_n);
        adjusted_pixel_rate = mul_u32_u32(adjusted_mode->crtc_clock * 1000, multiplier_m);
        crtc_state->cmrr.cmrr_m = do_div(adjusted_pixel_rate, crtc_state->cmrr.cmrr_n);

        return vtotal;
}

static
void intel_vrr_compute_cmrr_timings(struct intel_crtc_state *crtc_state)
{
        crtc_state->cmrr.enable = true;
        /*
         * TODO: Compute precise target refresh rate to determine
         * if video_mode_required should be true. Currently set to
         * false due to uncertainty about the precise target
         * refresh Rate.
         */
        crtc_state->vrr.vmax = cmrr_get_vtotal(crtc_state, false);
        crtc_state->vrr.vmin = crtc_state->vrr.vmax;
        crtc_state->vrr.flipline = crtc_state->vrr.vmin;
        crtc_state->mode_flags |= I915_MODE_FLAG_VRR;
}

static
void intel_vrr_compute_vrr_timings(struct intel_crtc_state *crtc_state)
{
        crtc_state->vrr.enable = true;
        crtc_state->mode_flags |= I915_MODE_FLAG_VRR;
}

/*
 * For fixed refresh rate mode Vmin, Vmax and Flipline all are set to
 * Vtotal value.
 */
static
int intel_vrr_fixed_rr_vtotal(const struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);
        int crtc_vtotal = crtc_state->hw.adjusted_mode.crtc_vtotal;

        if (DISPLAY_VER(display) >= 13)
                return crtc_vtotal;
        else
                return crtc_vtotal -
                        intel_vrr_real_vblank_delay(crtc_state);
}

static
int intel_vrr_fixed_rr_vmax(const struct intel_crtc_state *crtc_state)
{
        return intel_vrr_fixed_rr_vtotal(crtc_state);
}

static
int intel_vrr_fixed_rr_vmin(const struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);

        return intel_vrr_fixed_rr_vtotal(crtc_state) -
                intel_vrr_flipline_offset(display);
}

static
int intel_vrr_fixed_rr_flipline(const struct intel_crtc_state *crtc_state)
{
        return intel_vrr_fixed_rr_vtotal(crtc_state);
}

void intel_vrr_set_fixed_rr_timings(const struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);
        enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;

        if (!intel_vrr_possible(crtc_state))
                return;

        intel_de_write(display, TRANS_VRR_VMIN(display, cpu_transcoder),
                       intel_vrr_fixed_rr_vmin(crtc_state) - 1);
        intel_de_write(display, TRANS_VRR_VMAX(display, cpu_transcoder),
                       intel_vrr_fixed_rr_vmax(crtc_state) - 1);
        intel_de_write(display, TRANS_VRR_FLIPLINE(display, cpu_transcoder),
                       intel_vrr_fixed_rr_flipline(crtc_state) - 1);
}

static
void intel_vrr_compute_fixed_rr_timings(struct intel_crtc_state *crtc_state)
{
        /*
         * For fixed rr,  vmin = vmax = flipline.
         * vmin is already set to crtc_vtotal set vmax and flipline the same.
         */
        crtc_state->vrr.vmax = crtc_state->hw.adjusted_mode.crtc_vtotal;
        crtc_state->vrr.flipline = crtc_state->hw.adjusted_mode.crtc_vtotal;
}

static
int intel_vrr_compute_vmin(struct intel_crtc_state *crtc_state)
{
        /*
         * To make fixed rr and vrr work seamless the guardband/pipeline full
         * should be set such that it satisfies both the fixed and variable
         * timings.
         * For this set the vmin as crtc_vtotal. With this we never need to
         * change anything to do with the guardband.
         */
        return crtc_state->hw.adjusted_mode.crtc_vtotal;
}

static
int intel_vrr_compute_vmax(struct intel_connector *connector,
                           const struct drm_display_mode *adjusted_mode)
{
        const struct drm_display_info *info = &connector->base.display_info;
        int vmax;

        vmax = adjusted_mode->crtc_clock * 1000 /
                (adjusted_mode->crtc_htotal * info->monitor_range.min_vfreq);
        vmax = max_t(int, vmax, adjusted_mode->crtc_vtotal);

        return vmax;
}

void
intel_vrr_compute_config(struct intel_crtc_state *crtc_state,
                         struct drm_connector_state *conn_state)
{
        struct intel_display *display = to_intel_display(crtc_state);
        struct intel_connector *connector =
                to_intel_connector(conn_state->connector);
        struct intel_dp *intel_dp = intel_attached_dp(connector);
        bool is_edp = intel_dp_is_edp(intel_dp);
        struct drm_display_mode *adjusted_mode = &crtc_state->hw.adjusted_mode;
        int vmin, vmax;

        if (!HAS_VRR(display))
                return;

        if (adjusted_mode->flags & DRM_MODE_FLAG_INTERLACE)
                return;

        crtc_state->vrr.in_range =
                intel_vrr_is_in_range(connector, drm_mode_vrefresh(adjusted_mode));

        /*
         * Allow fixed refresh rate with VRR Timing Generator.
         * For now set the vrr.in_range to 0, to allow fixed_rr but skip actual
         * VRR and LRR.
         * #TODO For actual VRR with joiner, we need to figure out how to
         * correctly sequence transcoder level stuff vs. pipe level stuff
         * in the commit.
         */
        if (crtc_state->joiner_pipes)
                crtc_state->vrr.in_range = false;

        vmin = intel_vrr_compute_vmin(crtc_state);

        if (crtc_state->vrr.in_range) {
                if (HAS_LRR(display))
                        crtc_state->update_lrr = true;
                vmax = intel_vrr_compute_vmax(connector, adjusted_mode);
        } else {
                vmax = vmin;
        }

        crtc_state->vrr.vmin = vmin;
        crtc_state->vrr.vmax = vmax;

        crtc_state->vrr.flipline = crtc_state->vrr.vmin;

        if (crtc_state->uapi.vrr_enabled && vmin < vmax)
                intel_vrr_compute_vrr_timings(crtc_state);
        else if (is_cmrr_frac_required(crtc_state) && is_edp)
                intel_vrr_compute_cmrr_timings(crtc_state);
        else
                intel_vrr_compute_fixed_rr_timings(crtc_state);

        /*
         * flipline determines the min vblank length the hardware will
         * generate, and on ICL/TGL flipline>=vmin+1, hence we reduce
         * vmin by one to make sure we can get the actual min vblank length.
         */
        crtc_state->vrr.vmin -= intel_vrr_flipline_offset(display);

        if (HAS_AS_SDP(display)) {
                crtc_state->vrr.vsync_start =
                        (crtc_state->hw.adjusted_mode.crtc_vtotal -
                         crtc_state->hw.adjusted_mode.vsync_start);
                crtc_state->vrr.vsync_end =
                        (crtc_state->hw.adjusted_mode.crtc_vtotal -
                         crtc_state->hw.adjusted_mode.vsync_end);
        }
}

void intel_vrr_compute_config_late(struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);
        const struct drm_display_mode *adjusted_mode = &crtc_state->hw.adjusted_mode;

        if (!intel_vrr_possible(crtc_state))
                return;

        if (DISPLAY_VER(display) >= 13) {
                crtc_state->vrr.guardband =
                        crtc_state->vrr.vmin - adjusted_mode->crtc_vblank_start;
        } else {
                /* hardware imposes one extra scanline somewhere */
                crtc_state->vrr.pipeline_full =
                        min(255, crtc_state->vrr.vmin - adjusted_mode->crtc_vblank_start -
                            crtc_state->framestart_delay - 1);

                /*
                 * vmin/vmax/flipline also need to be adjusted by
                 * the vblank delay to maintain correct vtotals.
                 */
                crtc_state->vrr.vmin -= intel_vrr_real_vblank_delay(crtc_state);
                crtc_state->vrr.vmax -= intel_vrr_real_vblank_delay(crtc_state);
                crtc_state->vrr.flipline -= intel_vrr_real_vblank_delay(crtc_state);
        }
}

static u32 trans_vrr_ctl(const struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);

        if (DISPLAY_VER(display) >= 14)
                return VRR_CTL_FLIP_LINE_EN |
                        XELPD_VRR_CTL_VRR_GUARDBAND(crtc_state->vrr.guardband);
        else if (DISPLAY_VER(display) >= 13)
                return VRR_CTL_IGN_MAX_SHIFT | VRR_CTL_FLIP_LINE_EN |
                        XELPD_VRR_CTL_VRR_GUARDBAND(crtc_state->vrr.guardband);
        else
                return VRR_CTL_IGN_MAX_SHIFT | VRR_CTL_FLIP_LINE_EN |
                        VRR_CTL_PIPELINE_FULL(crtc_state->vrr.pipeline_full) |
                        VRR_CTL_PIPELINE_FULL_OVERRIDE;
}

void intel_vrr_set_transcoder_timings(const struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);
        enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;

        if (!HAS_VRR(display))
                return;

        /*
         * Bspec says:
         * "(note: VRR needs to be programmed after
         *  TRANS_DDI_FUNC_CTL and before TRANS_CONF)."
         *
         * In practice it turns out that ICL can hang if
         * TRANS_VRR_VMAX/FLIPLINE are written before
         * enabling TRANS_DDI_FUNC_CTL.
         */
        drm_WARN_ON(display->drm,
                    !(intel_de_read(display, TRANS_DDI_FUNC_CTL(display, cpu_transcoder)) & TRANS_DDI_FUNC_ENABLE));

        /*
         * This bit seems to have two meanings depending on the platform:
         * TGL: generate VRR "safe window" for DSB vblank waits
         * ADL/DG2: make TRANS_SET_CONTEXT_LATENCY effective with VRR
         */
        if (IS_DISPLAY_VER(display, 12, 13))
                intel_de_rmw(display, CHICKEN_TRANS(display, cpu_transcoder),
                             0, PIPE_VBLANK_WITH_DELAY);

        if (!intel_vrr_possible(crtc_state)) {
                intel_de_write(display,
                               TRANS_VRR_CTL(display, cpu_transcoder), 0);
                return;
        }

        if (crtc_state->cmrr.enable) {
                intel_de_write(display, TRANS_CMRR_M_HI(display, cpu_transcoder),
                               upper_32_bits(crtc_state->cmrr.cmrr_m));
                intel_de_write(display, TRANS_CMRR_M_LO(display, cpu_transcoder),
                               lower_32_bits(crtc_state->cmrr.cmrr_m));
                intel_de_write(display, TRANS_CMRR_N_HI(display, cpu_transcoder),
                               upper_32_bits(crtc_state->cmrr.cmrr_n));
                intel_de_write(display, TRANS_CMRR_N_LO(display, cpu_transcoder),
                               lower_32_bits(crtc_state->cmrr.cmrr_n));
        }

        intel_vrr_set_fixed_rr_timings(crtc_state);

        if (!intel_vrr_always_use_vrr_tg(display) && !crtc_state->vrr.enable)
                intel_de_write(display, TRANS_VRR_CTL(display, cpu_transcoder),
                               trans_vrr_ctl(crtc_state));

        if (HAS_AS_SDP(display))
                intel_de_write(display,
                               TRANS_VRR_VSYNC(display, cpu_transcoder),
                               VRR_VSYNC_END(crtc_state->vrr.vsync_end) |
                               VRR_VSYNC_START(crtc_state->vrr.vsync_start));
}

void intel_vrr_send_push(struct intel_dsb *dsb,
                         const struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);
        enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;

        if (!crtc_state->vrr.enable)
                return;

        if (dsb)
                intel_dsb_nonpost_start(dsb);

        intel_de_write_dsb(display, dsb,
                           TRANS_PUSH(display, cpu_transcoder),
                           TRANS_PUSH_EN | TRANS_PUSH_SEND);

        if (dsb)
                intel_dsb_nonpost_end(dsb);
}

void intel_vrr_check_push_sent(struct intel_dsb *dsb,
                               const struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);
        struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
        enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;

        if (!crtc_state->vrr.enable)
                return;

        /*
         * Make sure the push send bit has cleared. This should
         * already be the case as long as the caller makes sure
         * this is called after the delayed vblank has occurred.
         */
        if (dsb) {
                int wait_us, count;

                wait_us = 2;
                count = 1;

                /*
                 * If the bit hasn't cleared the DSB will
                 * raise the poll error interrupt.
                 */
                intel_dsb_poll(dsb, TRANS_PUSH(display, cpu_transcoder),
                               TRANS_PUSH_SEND, 0, wait_us, count);
        } else {
                if (intel_vrr_is_push_sent(crtc_state))
                        drm_err(display->drm, "[CRTC:%d:%s] VRR push send still pending\n",
                                crtc->base.base.id, crtc->base.name);
        }
}

bool intel_vrr_is_push_sent(const struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);
        enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;

        if (!crtc_state->vrr.enable)
                return false;

        return intel_de_read(display, TRANS_PUSH(display, cpu_transcoder)) & TRANS_PUSH_SEND;
}

bool intel_vrr_always_use_vrr_tg(struct intel_display *display)
{
        if (!HAS_VRR(display))
                return false;

        if (DISPLAY_VER(display) >= 30)
                return true;

        return false;
}

static
void intel_vrr_set_db_point_and_transmission_line(const struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);
        enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;

        /*
         * For BMG and LNL+ onwards the EMP_AS_SDP_TL is used for programming
         * double buffering point and transmission line for VRR packets for
         * HDMI2.1/DP/eDP/DP->HDMI2.1 PCON.
         * Since currently we support VRR only for DP/eDP, so this is programmed
         * to for Adaptive Sync SDP to Vsync start.
         */
        if (DISPLAY_VERx100(display) == 1401 || DISPLAY_VER(display) >= 20)
                intel_de_write(display,
                               EMP_AS_SDP_TL(display, cpu_transcoder),
                               EMP_AS_SDP_DB_TL(crtc_state->vrr.vsync_start));
}

void intel_vrr_enable(const struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);
        enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;

        if (!crtc_state->vrr.enable)
                return;

        intel_de_write(display, TRANS_VRR_VMIN(display, cpu_transcoder),
                       crtc_state->vrr.vmin - 1);
        intel_de_write(display, TRANS_VRR_VMAX(display, cpu_transcoder),
                       crtc_state->vrr.vmax - 1);
        intel_de_write(display, TRANS_VRR_FLIPLINE(display, cpu_transcoder),
                       crtc_state->vrr.flipline - 1);

        intel_de_write(display, TRANS_PUSH(display, cpu_transcoder),
                       TRANS_PUSH_EN);

        if (!intel_vrr_always_use_vrr_tg(display)) {
                intel_vrr_set_db_point_and_transmission_line(crtc_state);

                if (crtc_state->cmrr.enable) {
                        intel_de_write(display, TRANS_VRR_CTL(display, cpu_transcoder),
                                       VRR_CTL_VRR_ENABLE | VRR_CTL_CMRR_ENABLE |
                                       trans_vrr_ctl(crtc_state));
                } else {
                        intel_de_write(display, TRANS_VRR_CTL(display, cpu_transcoder),
                                       VRR_CTL_VRR_ENABLE | trans_vrr_ctl(crtc_state));
                }
        }
}

void intel_vrr_disable(const struct intel_crtc_state *old_crtc_state)
{
        struct intel_display *display = to_intel_display(old_crtc_state);
        enum transcoder cpu_transcoder = old_crtc_state->cpu_transcoder;

        if (!old_crtc_state->vrr.enable)
                return;

        if (!intel_vrr_always_use_vrr_tg(display)) {
                intel_de_write(display, TRANS_VRR_CTL(display, cpu_transcoder),
                               trans_vrr_ctl(old_crtc_state));
                intel_de_wait_for_clear(display,
                                        TRANS_VRR_STATUS(display, cpu_transcoder),
                                        VRR_STATUS_VRR_EN_LIVE, 1000);
                intel_de_write(display, TRANS_PUSH(display, cpu_transcoder), 0);
        }

        intel_vrr_set_fixed_rr_timings(old_crtc_state);
}

void intel_vrr_transcoder_enable(const struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);
        enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;

        if (!HAS_VRR(display))
                return;

        intel_vrr_set_transcoder_timings(crtc_state);

        if (!intel_vrr_possible(crtc_state))
                return;

        if (!intel_vrr_always_use_vrr_tg(display)) {
                intel_de_write(display, TRANS_VRR_CTL(display, cpu_transcoder),
                               trans_vrr_ctl(crtc_state));
                return;
        }

        intel_de_write(display, TRANS_PUSH(display, cpu_transcoder),
                       TRANS_PUSH_EN);

        intel_vrr_set_db_point_and_transmission_line(crtc_state);

        intel_de_write(display, TRANS_VRR_CTL(display, cpu_transcoder),
                       VRR_CTL_VRR_ENABLE | trans_vrr_ctl(crtc_state));
}

void intel_vrr_transcoder_disable(const struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);
        enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;

        if (!HAS_VRR(display))
                return;

        if (!intel_vrr_possible(crtc_state))
                return;

        intel_de_write(display, TRANS_VRR_CTL(display, cpu_transcoder), 0);

        intel_de_wait_for_clear(display, TRANS_VRR_STATUS(display, cpu_transcoder),
                                VRR_STATUS_VRR_EN_LIVE, 1000);
        intel_de_write(display, TRANS_PUSH(display, cpu_transcoder), 0);
}

bool intel_vrr_is_fixed_rr(const struct intel_crtc_state *crtc_state)
{
        return crtc_state->vrr.flipline &&
               crtc_state->vrr.flipline == crtc_state->vrr.vmax &&
               crtc_state->vrr.flipline == intel_vrr_vmin_flipline(crtc_state);
}

void intel_vrr_get_config(struct intel_crtc_state *crtc_state)
{
        struct intel_display *display = to_intel_display(crtc_state);
        enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
        u32 trans_vrr_ctl, trans_vrr_vsync;
        bool vrr_enable;

        trans_vrr_ctl = intel_de_read(display,
                                      TRANS_VRR_CTL(display, cpu_transcoder));

        if (HAS_CMRR(display))
                crtc_state->cmrr.enable = (trans_vrr_ctl & VRR_CTL_CMRR_ENABLE);

        if (crtc_state->cmrr.enable) {
                crtc_state->cmrr.cmrr_n =
                        intel_de_read64_2x32(display, TRANS_CMRR_N_LO(display, cpu_transcoder),
                                             TRANS_CMRR_N_HI(display, cpu_transcoder));
                crtc_state->cmrr.cmrr_m =
                        intel_de_read64_2x32(display, TRANS_CMRR_M_LO(display, cpu_transcoder),
                                             TRANS_CMRR_M_HI(display, cpu_transcoder));
        }

        if (DISPLAY_VER(display) >= 13)
                crtc_state->vrr.guardband =
                        REG_FIELD_GET(XELPD_VRR_CTL_VRR_GUARDBAND_MASK, trans_vrr_ctl);
        else
                if (trans_vrr_ctl & VRR_CTL_PIPELINE_FULL_OVERRIDE)
                        crtc_state->vrr.pipeline_full =
                                REG_FIELD_GET(VRR_CTL_PIPELINE_FULL_MASK, trans_vrr_ctl);

        if (trans_vrr_ctl & VRR_CTL_FLIP_LINE_EN) {
                crtc_state->vrr.flipline = intel_de_read(display,
                                                         TRANS_VRR_FLIPLINE(display, cpu_transcoder)) + 1;
                crtc_state->vrr.vmax = intel_de_read(display,
                                                     TRANS_VRR_VMAX(display, cpu_transcoder)) + 1;
                crtc_state->vrr.vmin = intel_de_read(display,
                                                     TRANS_VRR_VMIN(display, cpu_transcoder)) + 1;

                /*
                 * For platforms that always use VRR Timing Generator, the VTOTAL.Vtotal
                 * bits are not filled. Since for these platforms TRAN_VMIN is always
                 * filled with crtc_vtotal, use TRAN_VRR_VMIN to get the vtotal for
                 * adjusted_mode.
                 */
                if (intel_vrr_always_use_vrr_tg(display))
                        crtc_state->hw.adjusted_mode.crtc_vtotal =
                                intel_vrr_vmin_vtotal(crtc_state);

                if (HAS_AS_SDP(display)) {
                        trans_vrr_vsync =
                                intel_de_read(display,
                                              TRANS_VRR_VSYNC(display, cpu_transcoder));
                        crtc_state->vrr.vsync_start =
                                REG_FIELD_GET(VRR_VSYNC_START_MASK, trans_vrr_vsync);
                        crtc_state->vrr.vsync_end =
                                REG_FIELD_GET(VRR_VSYNC_END_MASK, trans_vrr_vsync);
                }
        }

        vrr_enable = trans_vrr_ctl & VRR_CTL_VRR_ENABLE;

        if (intel_vrr_always_use_vrr_tg(display))
                crtc_state->vrr.enable = vrr_enable && !intel_vrr_is_fixed_rr(crtc_state);
        else
                crtc_state->vrr.enable = vrr_enable;

        /*
         * #TODO: For Both VRR and CMRR the flag I915_MODE_FLAG_VRR is set for mode_flags.
         * Since CMRR is currently disabled, set this flag for VRR for now.
         * Need to keep this in mind while re-enabling CMRR.
         */
        if (crtc_state->vrr.enable)
                crtc_state->mode_flags |= I915_MODE_FLAG_VRR;
}