// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2012, 2015-2019, The Linux Foundation. All rights reserved.
 */

#define pr_fmt(fmt)	"%s: " fmt, __func__

#include <linux/bitmap.h>
#include <linux/errno.h>
#include <linux/iopoll.h>
#include <linux/mutex.h>

#include "sde_rotator_r1_hwio.h"
#include "sde_rotator_base.h"
#include "sde_rotator_util.h"
#include "sde_rotator_r1_internal.h"
#include "sde_rotator_core.h"
#include "sde_rotator_trace.h"

#define SMP_MB_SIZE		(mdss_res->smp_mb_size)
#define SMP_MB_CNT		(mdss_res->smp_mb_cnt)
#define SMP_MB_ENTRY_SIZE	16
#define MAX_BPP 4

#define PIPE_CLEANUP_TIMEOUT_US 100000

/* following offsets are relative to ctrl register bit offset */
#define CLK_FORCE_ON_OFFSET	0x0
#define CLK_FORCE_OFF_OFFSET	0x1
/* following offsets are relative to status register bit offset */
#define CLK_STATUS_OFFSET	0x0

#define QOS_LUT_NRT_READ	0x0
#define PANIC_LUT_NRT_READ	0x0
#define ROBUST_LUT_NRT_READ	0xFFFF

/* Priority 2, no panic */
#define VBLANK_PANIC_DEFAULT_CONFIG 0x200000

static inline void sde_mdp_pipe_write(struct sde_mdp_pipe *pipe,
				       u32 reg, u32 val)
{
	SDEROT_DBG("pipe%d:%6.6x:%8.8x\n", pipe->num, pipe->offset + reg, val);
	writel_relaxed(val, pipe->base + reg);
}

static int sde_mdp_pipe_qos_lut(struct sde_mdp_pipe *pipe)
{
	u32 qos_lut;

	qos_lut = QOS_LUT_NRT_READ; /* low priority for nrt */

	trace_rot_perf_set_qos_luts(pipe->num, pipe->src_fmt->format,
		qos_lut, sde_mdp_is_linear_format(pipe->src_fmt));

	sde_mdp_pipe_write(pipe, SDE_MDP_REG_SSPP_CREQ_LUT,
		qos_lut);

	return 0;
}

/**
 * @sde_mdp_pipe_nrt_vbif_setup -
 * @mdata: pointer to global driver data.
 * @pipe: pointer to a pipe
 *
 * This function assumes that clocks are enabled, so it is callers
 * responsibility to enable clocks before calling this function.
 */
static void sde_mdp_pipe_nrt_vbif_setup(struct sde_rot_data_type *mdata,
					struct sde_mdp_pipe *pipe)
{
	uint32_t nrt_vbif_client_sel;

	if (pipe->type != SDE_MDP_PIPE_TYPE_DMA)
		return;

	nrt_vbif_client_sel = readl_relaxed(mdata->mdp_base +
				MMSS_MDP_RT_NRT_VBIF_CLIENT_SEL);
	if (sde_mdp_is_nrt_vbif_client(mdata, pipe))
		nrt_vbif_client_sel |= BIT(pipe->num - SDE_MDP_SSPP_DMA0);
	else
		nrt_vbif_client_sel &= ~BIT(pipe->num - SDE_MDP_SSPP_DMA0);
	SDEROT_DBG("mdp:%6.6x:%8.8x\n", MMSS_MDP_RT_NRT_VBIF_CLIENT_SEL,
			nrt_vbif_client_sel);
	writel_relaxed(nrt_vbif_client_sel,
			mdata->mdp_base + MMSS_MDP_RT_NRT_VBIF_CLIENT_SEL);
}

/**
 * sde_mdp_qos_vbif_remapper_setup - Program the VBIF QoS remapper
 *		registers based on real or non real time clients
 * @mdata:	Pointer to the global mdss data structure.
 * @pipe:	Pointer to source pipe struct to get xin id's.
 * @is_realtime:	To determine if pipe's client is real or
 *			non real time.
 * This function assumes that clocks are on, so it is caller responsibility to
 * call this function with clocks enabled.
 */
static void sde_mdp_qos_vbif_remapper_setup(struct sde_rot_data_type *mdata,
			struct sde_mdp_pipe *pipe, bool is_realtime)
{
	u32 mask, reg_val, i, vbif_qos;

	if (mdata->npriority_lvl == 0)
		return;

	for (i = 0; i < mdata->npriority_lvl; i++) {
		reg_val = SDE_VBIF_READ(mdata, SDE_VBIF_QOS_REMAP_BASE + i*4);
		mask = 0x3 << (pipe->xin_id * 2);
		reg_val &= ~(mask);
		vbif_qos = is_realtime ?
			mdata->vbif_rt_qos[i] : mdata->vbif_nrt_qos[i];
		reg_val |= vbif_qos << (pipe->xin_id * 2);
		SDE_VBIF_WRITE(mdata, SDE_VBIF_QOS_REMAP_BASE + i*4, reg_val);
	}
}

struct sde_mdp_pipe *sde_mdp_pipe_assign(struct sde_rot_data_type *mdata,
	struct sde_mdp_mixer *mixer, u32 ndx)
{
	struct sde_mdp_pipe *pipe = NULL;
	static struct sde_mdp_pipe sde_pipe[16];
	static const u32 offset[] = {0x00025000, 0x00027000};
	static const u32 xin_id[] = {2, 10};
	static const struct sde_mdp_shared_reg_ctrl clk_ctrl[] = {
		{0x2AC, 8},
		{0x2B4, 8}
	};

	if (ndx >= ARRAY_SIZE(offset)) {
		SDEROT_ERR("invalid parameters\n");
		return ERR_PTR(-EINVAL);
	}

	pipe = &sde_pipe[ndx];
	pipe->num = ndx + SDE_MDP_SSPP_DMA0;
	pipe->offset = offset[pipe->num - SDE_MDP_SSPP_DMA0];
	pipe->xin_id = xin_id[pipe->num - SDE_MDP_SSPP_DMA0];
	pipe->base = mdata->sde_io.base + pipe->offset;
	pipe->type = SDE_MDP_PIPE_TYPE_DMA;
	pipe->mixer_left = mixer;
	pipe->clk_ctrl = clk_ctrl[pipe->num - SDE_MDP_SSPP_DMA0];

	return pipe;
}

int sde_mdp_pipe_destroy(struct sde_mdp_pipe *pipe)
{
	return 0;
}

void sde_mdp_pipe_position_update(struct sde_mdp_pipe *pipe,
		struct sde_rect *src, struct sde_rect *dst)
{
	u32 src_size, src_xy, dst_size, dst_xy;

	src_size = (src->h << 16) | src->w;
	src_xy = (src->y << 16) | src->x;
	dst_size = (dst->h << 16) | dst->w;
	dst_xy = (dst->y << 16) | dst->x;

	sde_mdp_pipe_write(pipe, SDE_MDP_REG_SSPP_SRC_SIZE, src_size);
	sde_mdp_pipe_write(pipe, SDE_MDP_REG_SSPP_SRC_XY, src_xy);
	sde_mdp_pipe_write(pipe, SDE_MDP_REG_SSPP_OUT_SIZE, dst_size);
	sde_mdp_pipe_write(pipe, SDE_MDP_REG_SSPP_OUT_XY, dst_xy);
}

static int sde_mdp_image_setup(struct sde_mdp_pipe *pipe,
					struct sde_mdp_data *data)
{
	u32 img_size, ystride0, ystride1;
	u32 width, height, decimation;
	int ret = 0;
	struct sde_rect dst, src;
	bool rotation = false;

	SDEROT_DBG(
		"ctl: %d pnum=%d wh=%dx%d src={%d,%d,%d,%d} dst={%d,%d,%d,%d}\n",
			pipe->mixer_left->ctl->num, pipe->num,
			pipe->img_width, pipe->img_height,
			pipe->src.x, pipe->src.y, pipe->src.w, pipe->src.h,
			pipe->dst.x, pipe->dst.y, pipe->dst.w, pipe->dst.h);

	width = pipe->img_width;
	height = pipe->img_height;

	if (pipe->flags & SDE_SOURCE_ROTATED_90)
		rotation = true;

	sde_mdp_get_plane_sizes(pipe->src_fmt, width, height,
			&pipe->src_planes, pipe->bwc_mode, rotation);

	if (data != NULL) {
		ret = sde_mdp_data_check(data, &pipe->src_planes,
			pipe->src_fmt);
		if (ret)
			return ret;
	}

	if ((pipe->flags & SDE_DEINTERLACE) &&
			!(pipe->flags & SDE_SOURCE_ROTATED_90)) {
		int i;

		for (i = 0; i < pipe->src_planes.num_planes; i++)
			pipe->src_planes.ystride[i] *= 2;
		width *= 2;
		height /= 2;
	}

	decimation = ((1 << pipe->horz_deci) - 1) << 8;
	decimation |= ((1 << pipe->vert_deci) - 1);
	if (decimation)
		SDEROT_DBG("Image decimation h=%d v=%d\n",
				pipe->horz_deci, pipe->vert_deci);

	dst = pipe->dst;
	src = pipe->src;

	ystride0 =  (pipe->src_planes.ystride[0]) |
			(pipe->src_planes.ystride[1] << 16);
	ystride1 =  (pipe->src_planes.ystride[2]) |
			(pipe->src_planes.ystride[3] << 16);

	img_size = (height << 16) | width;

	sde_mdp_pipe_position_update(pipe, &src, &dst);

	sde_mdp_pipe_write(pipe, SDE_MDP_REG_SSPP_SRC_IMG_SIZE, img_size);
	sde_mdp_pipe_write(pipe, SDE_MDP_REG_SSPP_SRC_YSTRIDE0, ystride0);
	sde_mdp_pipe_write(pipe, SDE_MDP_REG_SSPP_SRC_YSTRIDE1, ystride1);
	sde_mdp_pipe_write(pipe, SDE_MDP_REG_SSPP_DECIMATION_CONFIG,
			decimation);

	return 0;
}

static int sde_mdp_format_setup(struct sde_mdp_pipe *pipe)
{
	struct sde_mdp_format_params *fmt;
	u32 chroma_samp, unpack, src_format;
	u32 secure = 0;
	u32 opmode;
	struct sde_rot_data_type *mdata = sde_rot_get_mdata();

	fmt = pipe->src_fmt;

	if (pipe->flags & SDE_SECURE_OVERLAY_SESSION)
		secure = 0xF;

	opmode = pipe->bwc_mode;
	if (pipe->flags & SDE_FLIP_LR)
		opmode |= SDE_MDP_OP_FLIP_LR;
	if (pipe->flags & SDE_FLIP_UD)
		opmode |= SDE_MDP_OP_FLIP_UD;

	SDEROT_DBG("pnum=%d format=%d opmode=%x\n", pipe->num, fmt->format,
			opmode);

	chroma_samp = fmt->chroma_sample;
	if (pipe->flags & SDE_SOURCE_ROTATED_90) {
		if (chroma_samp == SDE_MDP_CHROMA_H2V1)
			chroma_samp = SDE_MDP_CHROMA_H1V2;
		else if (chroma_samp == SDE_MDP_CHROMA_H1V2)
			chroma_samp = SDE_MDP_CHROMA_H2V1;
	}

	src_format = (chroma_samp << 23) |
		     (fmt->fetch_planes << 19) |
		     (fmt->bits[C3_ALPHA] << 6) |
		     (fmt->bits[C2_R_Cr] << 4) |
		     (fmt->bits[C1_B_Cb] << 2) |
		     (fmt->bits[C0_G_Y] << 0);

	if (sde_mdp_is_tilea4x_format(fmt))
		src_format |= BIT(30);

	if (sde_mdp_is_tilea5x_format(fmt))
		src_format |= BIT(31);

	if (pipe->flags & SDE_ROT_90)
		src_format |= BIT(11); /* ROT90 */

	if (fmt->alpha_enable &&
			fmt->fetch_planes != SDE_MDP_PLANE_INTERLEAVED)
		src_format |= BIT(8); /* SRCC3_EN */

	unpack = (fmt->element[3] << 24) | (fmt->element[2] << 16) |
			(fmt->element[1] << 8) | (fmt->element[0] << 0);
	src_format |= ((fmt->unpack_count - 1) << 12) |
			(fmt->unpack_tight << 17) |
			(fmt->unpack_align_msb << 18) |
			((fmt->bpp - 1) << 9);

	if (sde_mdp_is_ubwc_format(fmt))
		opmode |= BIT(0);

	if (fmt->is_yuv)
		src_format |= BIT(15);

	if (fmt->frame_format != SDE_MDP_FMT_LINEAR
		&& mdata->highest_bank_bit) {
		sde_mdp_pipe_write(pipe, SDE_MDP_REG_SSPP_FETCH_CONFIG,
			SDE_MDP_FETCH_CONFIG_RESET_VALUE |
				 mdata->highest_bank_bit << 18);
	}

	sde_mdp_pipe_write(pipe, SDE_MDP_REG_SSPP_SRC_FORMAT, src_format);
	sde_mdp_pipe_write(pipe, SDE_MDP_REG_SSPP_SRC_UNPACK_PATTERN, unpack);
	sde_mdp_pipe_write(pipe, SDE_MDP_REG_SSPP_SRC_OP_MODE, opmode);
	sde_mdp_pipe_write(pipe, SDE_MDP_REG_SSPP_SRC_ADDR_SW_STATUS, secure);

	/* clear UBWC error */
	sde_mdp_pipe_write(pipe, SDE_MDP_REG_SSPP_UBWC_ERROR_STATUS, BIT(31));

	return 0;
}

static int sde_mdp_src_addr_setup(struct sde_mdp_pipe *pipe,
				   struct sde_mdp_data *src_data)
{
	struct sde_mdp_data data = *src_data;
	u32 x = 0, y = 0;
	int ret = 0;

	SDEROT_DBG("pnum=%d\n", pipe->num);

	ret = sde_mdp_data_check(&data, &pipe->src_planes, pipe->src_fmt);
	if (ret)
		return ret;

	sde_rot_data_calc_offset(&data, x, y,
		&pipe->src_planes, pipe->src_fmt);

	sde_mdp_pipe_write(pipe, SDE_MDP_REG_SSPP_SRC0_ADDR, data.p[0].addr);
	sde_mdp_pipe_write(pipe, SDE_MDP_REG_SSPP_SRC1_ADDR, data.p[1].addr);
	sde_mdp_pipe_write(pipe, SDE_MDP_REG_SSPP_SRC2_ADDR, data.p[2].addr);
	sde_mdp_pipe_write(pipe, SDE_MDP_REG_SSPP_SRC3_ADDR, data.p[3].addr);

	return 0;
}

static void sde_mdp_set_ot_limit_pipe(struct sde_mdp_pipe *pipe)
{
	struct sde_mdp_set_ot_params ot_params = {0,};

	ot_params.xin_id = pipe->xin_id;
	ot_params.num = pipe->num;
	ot_params.width = pipe->src.w;
	ot_params.height = pipe->src.h;
	ot_params.fps = 60;
	ot_params.reg_off_vbif_lim_conf = MMSS_VBIF_RD_LIM_CONF;
	ot_params.reg_off_mdp_clk_ctrl = pipe->clk_ctrl.reg_off;
	ot_params.bit_off_mdp_clk_ctrl = pipe->clk_ctrl.bit_off +
		CLK_FORCE_ON_OFFSET;
	ot_params.fmt = (pipe->src_fmt) ? pipe->src_fmt->format : 0;

	sde_mdp_set_ot_limit(&ot_params);
}

int sde_mdp_pipe_queue_data(struct sde_mdp_pipe *pipe,
			     struct sde_mdp_data *src_data)
{
	int ret = 0;
	u32 params_changed;
	struct sde_rot_data_type *mdata = sde_rot_get_mdata();

	if (!pipe) {
		SDEROT_ERR("pipe not setup properly for queue\n");
		return -ENODEV;
	}

	/*
	 * Reprogram the pipe when there is no dedicated wfd blk and
	 * virtual mixer is allocated for the DMA pipe during concurrent
	 * line and block mode operations
	 */

	params_changed = (pipe->params_changed);
	if (params_changed) {
		bool is_realtime = !(pipe->mixer_left->rotator_mode);

		sde_mdp_qos_vbif_remapper_setup(mdata, pipe, is_realtime);

		if (mdata->vbif_nrt_io.base)
			sde_mdp_pipe_nrt_vbif_setup(mdata, pipe);
	}

	if (params_changed) {
		pipe->params_changed = 0;

		ret = sde_mdp_image_setup(pipe, src_data);
		if (ret) {
			SDEROT_ERR("image setup error for pnum=%d\n",
					pipe->num);
			goto done;
		}

		ret = sde_mdp_format_setup(pipe);
		if (ret) {
			SDEROT_ERR("format %d setup error pnum=%d\n",
			       pipe->src_fmt->format, pipe->num);
			goto done;
		}

		if (test_bit(SDE_QOS_PER_PIPE_LUT, mdata->sde_qos_map))
			sde_mdp_pipe_qos_lut(pipe);

		sde_mdp_set_ot_limit_pipe(pipe);
	}

	ret = sde_mdp_src_addr_setup(pipe, src_data);
	if (ret) {
		SDEROT_ERR("addr setup error for pnum=%d\n", pipe->num);
		goto done;
	}

	sde_mdp_mixer_pipe_update(pipe, pipe->mixer_left,
			params_changed);
done:
	return ret;
}