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

#include <linux/debugfs.h>

#include <drm/drm_print.h>

#include "intel_cdclk.h"
#include "intel_display_core.h"
#include "intel_display_types.h"
#include "intel_vblank.h"
#include "intel_vdsc.h"
#include "skl_prefill.h"
#include "skl_scaler.h"
#include "skl_watermark.h"

static unsigned int prefill_usecs_to_lines(const struct intel_crtc_state *crtc_state,
                                           unsigned int usecs)
{
        const struct drm_display_mode *pipe_mode = &crtc_state->hw.pipe_mode;

        return DIV_ROUND_UP_ULL(mul_u32_u32(pipe_mode->crtc_clock, usecs << 16),
                                pipe_mode->crtc_htotal * 1000);
}

static void prefill_init(struct skl_prefill_ctx *ctx,
                         const struct intel_crtc_state *crtc_state)
{
        memset(ctx, 0, sizeof(*ctx));

        ctx->prefill.fixed = crtc_state->framestart_delay << 16;

        /* 20 usec for translation walks/etc. */
        ctx->prefill.fixed += prefill_usecs_to_lines(crtc_state, 20);

        ctx->prefill.dsc = intel_vdsc_prefill_lines(crtc_state);
}

static void prefill_init_nocdclk_worst(struct skl_prefill_ctx *ctx,
                                       const struct intel_crtc_state *crtc_state)
{
        prefill_init(ctx, crtc_state);

        ctx->prefill.wm0 = skl_wm0_prefill_lines_worst(crtc_state);
        ctx->prefill.scaler_1st = skl_scaler_1st_prefill_lines_worst(crtc_state);
        ctx->prefill.scaler_2nd = skl_scaler_2nd_prefill_lines_worst(crtc_state);

        ctx->adj.scaler_1st = skl_scaler_1st_prefill_adjustment_worst(crtc_state);
        ctx->adj.scaler_2nd = skl_scaler_2nd_prefill_adjustment_worst(crtc_state);
}

static void prefill_init_nocdclk(struct skl_prefill_ctx *ctx,
                                 const struct intel_crtc_state *crtc_state)
{
        prefill_init(ctx, crtc_state);

        ctx->prefill.wm0 = skl_wm0_prefill_lines(crtc_state);
        ctx->prefill.scaler_1st = skl_scaler_1st_prefill_lines(crtc_state);
        ctx->prefill.scaler_2nd = skl_scaler_2nd_prefill_lines(crtc_state);

        ctx->adj.scaler_1st = skl_scaler_1st_prefill_adjustment(crtc_state);
        ctx->adj.scaler_2nd = skl_scaler_2nd_prefill_adjustment(crtc_state);
}

static unsigned int prefill_adjust(unsigned int value, unsigned int factor)
{
        return DIV_ROUND_UP_ULL(mul_u32_u32(value, factor), 0x10000);
}

static unsigned int prefill_lines_nocdclk(const struct skl_prefill_ctx *ctx)
{
        unsigned int prefill = 0;

        prefill += ctx->prefill.dsc;
        prefill = prefill_adjust(prefill, ctx->adj.scaler_2nd);

        prefill += ctx->prefill.scaler_2nd;
        prefill = prefill_adjust(prefill, ctx->adj.scaler_1st);

        prefill += ctx->prefill.scaler_1st;
        prefill += ctx->prefill.wm0;

        return prefill;
}

static unsigned int prefill_lines_cdclk(const struct skl_prefill_ctx *ctx)
{
        return prefill_adjust(prefill_lines_nocdclk(ctx), ctx->adj.cdclk);
}

static unsigned int prefill_lines_full(const struct skl_prefill_ctx *ctx)
{
        return ctx->prefill.fixed + prefill_lines_cdclk(ctx);
}

void skl_prefill_init_worst(struct skl_prefill_ctx *ctx,
                            const struct intel_crtc_state *crtc_state)
{
        prefill_init_nocdclk_worst(ctx, crtc_state);

        ctx->adj.cdclk = intel_cdclk_prefill_adjustment_worst(crtc_state);

        ctx->prefill.full = prefill_lines_full(ctx);
}

void skl_prefill_init(struct skl_prefill_ctx *ctx,
                      const struct intel_crtc_state *crtc_state)
{
        prefill_init_nocdclk(ctx, crtc_state);

        ctx->adj.cdclk = intel_cdclk_prefill_adjustment(crtc_state);

        ctx->prefill.full = prefill_lines_full(ctx);
}

static unsigned int prefill_lines_with_latency(const struct skl_prefill_ctx *ctx,
                                               const struct intel_crtc_state *crtc_state,
                                               unsigned int latency_us)
{
        return ctx->prefill.full + prefill_usecs_to_lines(crtc_state, latency_us);
}

int skl_prefill_min_guardband(const struct skl_prefill_ctx *ctx,
                              const struct intel_crtc_state *crtc_state,
                              unsigned int latency_us)
{
        unsigned int prefill = prefill_lines_with_latency(ctx, crtc_state, latency_us);

        return DIV_ROUND_UP(prefill, 0x10000);
}

static unsigned int prefill_guardband(const struct intel_crtc_state *crtc_state)
{
        return intel_crtc_vblank_length(crtc_state) << 16;
}

bool skl_prefill_vblank_too_short(const struct skl_prefill_ctx *ctx,
                                  const struct intel_crtc_state *crtc_state,
                                  unsigned int latency_us)
{
        unsigned int guardband = prefill_guardband(crtc_state);
        unsigned int prefill = prefill_lines_with_latency(ctx, crtc_state, latency_us);

        return guardband < prefill;
}

int skl_prefill_min_cdclk(const struct skl_prefill_ctx *ctx,
                          const struct intel_crtc_state *crtc_state)
{
        unsigned int prefill_unadjusted = prefill_lines_nocdclk(ctx);
        unsigned int prefill_available = prefill_guardband(crtc_state) - ctx->prefill.fixed;

        return intel_cdclk_min_cdclk_for_prefill(crtc_state, prefill_unadjusted,
                                                 prefill_available);
}