Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e2e554bc authored by Samantha Tran's avatar Samantha Tran
Browse files

disp: snapshot of offline rotator 



This snapshot includes updates to offline rotator and supporting
files. Snapshot was taken from msm-4.14 as of commit 0f8fb25421ff
("cnss2: Add device version to SOC info structure").

Change-Id: I58674ba880de3d8722ed9119bfc2bee34b444917
Signed-off-by: default avatarSamantha Tran <samtran@codeaurora.org>
parent eeaef40e

msm/sde/sde_vbif.c

+36 −0
Original line number Diff line number Diff line
@@ -10,6 +10,7 @@ 
#include "sde_vbif.h"

#include "sde_hw_vbif.h"

#include "sde_trace.h"

#include "sde_rotator_vbif.h"



#define MAX_XIN_CLIENT	16
@@ -286,6 +287,41 @@ void sde_vbif_set_ot_limit(struct sde_kms *sde_kms, 
	mutex_unlock(&vbif->mutex);

}



void mdp_vbif_lock(struct platform_device *parent_pdev, bool enable)

{

	struct drm_device *ddev;

	struct sde_kms *sde_kms;

	struct sde_hw_vbif *vbif = NULL;

	int i;



	ddev = platform_get_drvdata(parent_pdev);

	if (!ddev || !ddev_to_msm_kms(ddev)) {

		SDE_ERROR("invalid drm device\n");

		return;

	}



	sde_kms = to_sde_kms(ddev_to_msm_kms(ddev));



	for (i = 0; i < ARRAY_SIZE(sde_kms->hw_vbif); i++) {

		if (sde_kms->hw_vbif[i] &&

				sde_kms->hw_vbif[i]->idx == VBIF_RT) {

			vbif = sde_kms->hw_vbif[i];

			break;

		}

	}



	if (!vbif) {

		SDE_DEBUG("invalid vbif structure\n");

		return;

	}



	if (enable)

		mutex_lock(&vbif->mutex);

	else

		mutex_unlock(&vbif->mutex);



}



bool sde_vbif_set_xin_halt(struct sde_kms *sde_kms,

		struct sde_vbif_set_xin_halt_params *params)

{

rotator/sde_rotator_base.c

+109 −12
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ 
#include "sde_rotator_trace.h"

#include "sde_rotator_debug.h"

#include "sde_rotator_dev.h"

#include "sde_rotator_vbif.h"



static inline u64 fudge_factor(u64 val, u32 numer, u32 denom)

{
@@ -70,6 +71,7 @@ u32 sde_apply_comp_ratio_factor(u32 quota, 


#define RES_1080p		(1088*1920)

#define RES_UHD		(3840*2160)

#define RES_WQXGA	(2560*1600)

#define XIN_HALT_TIMEOUT_US	0x4000



static int sde_mdp_wait_for_xin_halt(u32 xin_id)
@@ -132,18 +134,36 @@ static bool force_on_xin_clk(u32 bit_off, u32 clk_ctl_reg_off, bool enable) 
	return clk_forced_on;

}



void vbif_lock(struct platform_device *parent_pdev)

{

	if (!parent_pdev)

		return;



	mdp_vbif_lock(parent_pdev, true);

}



void vbif_unlock(struct platform_device *parent_pdev)

{

	if (!parent_pdev)

		return;



	mdp_vbif_lock(parent_pdev, false);

}



void sde_mdp_halt_vbif_xin(struct sde_mdp_vbif_halt_params *params)

{

	struct sde_rot_data_type *mdata = sde_rot_get_mdata();

	u32 reg_val;

	bool forced_on;

	int rc = 0;



	if (!mdata || !params || !params->reg_off_mdp_clk_ctrl) {

		SDEROT_ERR("null input parameter\n");

		return;

	}



	if (params->xin_id > MMSS_VBIF_NRT_VBIF_CLK_FORCE_CTRL0_XIN1) {

	if (!mdata->parent_pdev &&

		params->xin_id > MMSS_VBIF_NRT_VBIF_CLK_FORCE_CTRL0_XIN1) {

		SDEROT_ERR("xin_id:%d exceed max limit\n", params->xin_id);

		return;

	}
@@ -151,6 +171,8 @@ void sde_mdp_halt_vbif_xin(struct sde_mdp_vbif_halt_params *params) 
	forced_on = force_on_xin_clk(params->bit_off_mdp_clk_ctrl,

		params->reg_off_mdp_clk_ctrl, true);



	vbif_lock(mdata->parent_pdev);



	SDEROT_EVTLOG(forced_on, params->xin_id);



	reg_val = SDE_VBIF_READ(mdata, MMSS_VBIF_XIN_HALT_CTRL0);
@@ -158,12 +180,16 @@ void sde_mdp_halt_vbif_xin(struct sde_mdp_vbif_halt_params *params) 
		reg_val | BIT(params->xin_id));



	/* this is a polling operation */

	sde_mdp_wait_for_xin_halt(params->xin_id);

	rc = sde_mdp_wait_for_xin_halt(params->xin_id);

	if (rc == -ETIMEDOUT)

		params->xin_timeout = BIT(params->xin_id);



	reg_val = SDE_VBIF_READ(mdata, MMSS_VBIF_XIN_HALT_CTRL0);

	SDE_VBIF_WRITE(mdata, MMSS_VBIF_XIN_HALT_CTRL0,

		reg_val & ~BIT(params->xin_id));



	vbif_unlock(mdata->parent_pdev);



	if (forced_on)

		force_on_xin_clk(params->bit_off_mdp_clk_ctrl,

			params->reg_off_mdp_clk_ctrl, false);
@@ -209,18 +235,36 @@ u32 sde_mdp_get_ot_limit(u32 width, u32 height, u32 pixfmt, u32 fps, u32 is_rd) 
	SDEROT_DBG("w:%d h:%d fps:%d pixfmt:%8.8x yuv:%d res:%llu rd:%d\n",

		width, height, fps, pixfmt, is_yuv, res, is_rd);



	if (!is_yuv)

		goto exit;



	/*

	 * If (total_source_pixels <= 62208000  && YUV) -> RD/WROT=2 //1080p30

	 * If (total_source_pixels <= 124416000 && YUV) -> RD/WROT=4 //1080p60

	 * If (total_source_pixels <= 2160p && YUV && FPS <= 30) -> RD/WROT = 32

	 */

	switch (mdata->mdss_version) {

	case SDE_MDP_HW_REV_540:

		if (is_yuv) {

			if (res <= (RES_1080p * 30))

				ot_lim = 2;

			else if (res <= (RES_1080p * 60))

				ot_lim = 4;

			else if (res <= (RES_WQXGA * 60))

				ot_lim = 4;

			else if (res <= (RES_UHD * 30))

				ot_lim = 8;

		} else if (fmt->bpp == 4 && res <= (RES_WQXGA * 60)) {

			ot_lim = 16;

		}



		break;

	default:

		if (is_yuv) {

			if (res <= (RES_1080p * 30))

				ot_lim = 2;

			else if (res <= (RES_1080p * 60))

				ot_lim = 4;

		}

		break;

	}



exit:

	SDEROT_DBG("ot_lim=%d\n", ot_lim);
@@ -274,6 +318,8 @@ void sde_mdp_set_ot_limit(struct sde_mdp_set_ot_params *params) 
	u32 sts;

	bool forced_on;



	vbif_lock(mdata->parent_pdev);



	ot_lim = get_ot_limit(

		reg_off_vbif_lim_conf,

		bit_off_vbif_lim_conf,
@@ -319,6 +365,7 @@ void sde_mdp_set_ot_limit(struct sde_mdp_set_ot_params *params) 


	SDEROT_EVTLOG(params->num, params->xin_id, ot_lim);

exit:

	vbif_unlock(mdata->parent_pdev);

	return;

}
@@ -465,7 +512,7 @@ static int sde_mdp_parse_dt_handler(struct platform_device *pdev, 
	rc = of_property_read_u32_array(pdev->dev.of_node, prop_name,

					offsets, len);

	if (rc) {

		SDEROT_ERR("Error from prop %s : u32 array read\n", prop_name);

		SDEROT_DBG("Error from prop %s : u32 array read\n", prop_name);

		return -EINVAL;

	}
@@ -499,7 +546,7 @@ static void sde_mdp_parse_vbif_memtype(struct platform_device *pdev, 
			"qcom,mdss-rot-vbif-memtype");

	mdata->vbif_memtype = kcalloc(mdata->vbif_memtype_count,

			sizeof(u32), GFP_KERNEL);

	if (!mdata->vbif_memtype) {

	if (!mdata->vbif_memtype || !mdata->vbif_memtype_count) {

		mdata->vbif_memtype_count = 0;

		return;

	}
@@ -527,7 +574,7 @@ static void sde_mdp_parse_vbif_qos(struct platform_device *pdev, 
			"qcom,mdss-rot-vbif-qos-setting");

	mdata->vbif_nrt_qos = kcalloc(mdata->npriority_lvl,

			sizeof(u32), GFP_KERNEL);

	if (!mdata->vbif_nrt_qos) {

	if (!mdata->vbif_nrt_qos || !mdata->npriority_lvl) {

		mdata->npriority_lvl = 0;

		return;

	}
@@ -544,6 +591,16 @@ static void sde_mdp_parse_vbif_qos(struct platform_device *pdev, 
	}

}



static void sde_mdp_parse_vbif_xin_id(struct platform_device *pdev,

		struct sde_rot_data_type *mdata)

{

	mdata->vbif_xin_id[XIN_SSPP] = XIN_SSPP;

	mdata->vbif_xin_id[XIN_WRITEBACK] = XIN_WRITEBACK;



	sde_mdp_parse_dt_handler(pdev, "qcom,mdss-rot-xin-id",

					mdata->vbif_xin_id, MAX_XIN);

}



static void sde_mdp_parse_cdp_setting(struct platform_device *pdev,

		struct sde_rot_data_type *mdata)

{
@@ -674,6 +731,35 @@ static void sde_mdp_parse_inline_rot_lut_setting(struct platform_device *pdev, 
	}

}



static void sde_mdp_parse_rt_rotator(struct device_node *np)

{

	struct sde_rot_data_type *mdata = sde_rot_get_mdata();

	struct platform_device *pdev;

	struct of_phandle_args phargs;

	int rc = 0;



	rc = of_parse_phandle_with_args(np,

			"qcom,mdss-rot-parent", "#list-cells", 0, &phargs);



	if (rc)

		return;



	if (!phargs.np || !phargs.args_count) {

		SDEROT_ERR("invalid args\n");

		return;

	}



	pdev = of_find_device_by_node(phargs.np);

	if (pdev) {

		mdata->parent_pdev = pdev;

	} else {

		mdata->parent_pdev = NULL;

		SDEROT_ERR("Parent mdp node not available\n");

	}



	of_node_put(phargs.np);

}



static int sde_mdp_parse_dt_misc(struct platform_device *pdev,

		struct sde_rot_data_type *mdata)

{
@@ -702,6 +788,8 @@ static int sde_mdp_parse_dt_misc(struct platform_device *pdev, 


	sde_mdp_parse_vbif_qos(pdev, mdata);



	sde_mdp_parse_vbif_xin_id(pdev, mdata);



	sde_mdp_parse_vbif_memtype(pdev, mdata);



	sde_mdp_parse_rot_lut_setting(pdev, mdata);
@@ -820,6 +908,13 @@ int sde_rotator_base_init(struct sde_rot_data_type **pmdata, 
	int rc;

	struct sde_rot_data_type *mdata;





	/* if probe deferral happened, return early*/

	if (sde_rot_res) {

		SDEROT_ERR("Rotator data already initialized, skip init\n");

		return 0;

	}



	mdata = devm_kzalloc(&pdev->dev, sizeof(*mdata), GFP_KERNEL);

	if (mdata == NULL)

		return -ENOMEM;
@@ -846,6 +941,8 @@ int sde_rotator_base_init(struct sde_rot_data_type **pmdata, 
	SDEROT_DBG("SDE ROT VBIF HW Base addr=%pK len=0x%x\n",

			mdata->vbif_nrt_io.base, mdata->vbif_nrt_io.len);



	sde_mdp_parse_rt_rotator(pdev->dev.of_node);



	rc = sde_mdp_parse_dt_misc(pdev, mdata);

	if (rc) {

		SDEROT_ERR("Error in device tree : misc\n");

rotator/sde_rotator_base.h

+16 −0
Original line number Diff line number Diff line
@@ -11,6 +11,8 @@ 
#include <linux/kref.h>

#include <linux/kernel.h>

#include <linux/regulator/consumer.h>

#include <linux/of_platform.h>

#include <linux/platform_device.h>



#include "sde_rotator_hwio.h"

#include "sde_rotator_io_util.h"
@@ -41,11 +43,17 @@ 
#define SDE_MDP_HW_REV_500	SDE_MDP_REV(5, 0, 0)	/* sm8150 v1.0 */

#define SDE_MDP_HW_REV_520	SDE_MDP_REV(5, 2, 0)	/* sdmmagpie v1.0 */

#define SDE_MDP_HW_REV_530	SDE_MDP_REV(5, 3, 0)	/* sm6150 v1.0 */

#define SDE_MDP_HW_REV_540	SDE_MDP_REV(5, 4, 0)	/* sdmtrinket v1.0 */

#define SDE_MDP_HW_REV_600	SDE_MDP_REV(6, 0, 0)    /* msmnile+ v1.0 */



#define SDE_MDP_VBIF_4_LEVEL_REMAPPER	4

#define SDE_MDP_VBIF_8_LEVEL_REMAPPER	8



/* XIN mapping */

#define XIN_SSPP	0

#define XIN_WRITEBACK	1

#define MAX_XIN		2



struct sde_mult_factor {

	uint32_t numer;

	uint32_t denom;
@@ -70,11 +78,13 @@ struct sde_mdp_set_ot_params { 
 * @xin_id: xin port number of vbif

 * @reg_off_mdp_clk_ctrl: reg offset for vbif clock control

 * @bit_off_mdp_clk_ctrl: bit offset for vbif clock control

 * @xin_timeout: bit position indicates timeout on corresponding xin id

 */

struct sde_mdp_vbif_halt_params {

	u32 xin_id;

	u32 reg_off_mdp_clk_ctrl;

	u32 bit_off_mdp_clk_ctrl;

	u32 xin_timeout;

};



enum sde_bus_vote_type {
@@ -220,6 +230,7 @@ struct sde_rot_data_type { 
	u32 mdss_version;



	struct platform_device *pdev;

	struct platform_device *parent_pdev;

	struct sde_io_data sde_io;

	struct sde_io_data vbif_nrt_io;

	char __iomem *mdp_base;
@@ -248,6 +259,8 @@ struct sde_rot_data_type { 
	u32 *vbif_nrt_qos;

	u32 npriority_lvl;



	u32 vbif_xin_id[MAX_XIN];



	struct pm_qos_request pm_qos_rot_cpu_req;

	u32 rot_pm_qos_cpu_count;

	u32 rot_pm_qos_cpu_mask;
@@ -300,6 +313,9 @@ u32 sde_mdp_get_ot_limit(u32 width, u32 height, u32 pixfmt, u32 fps, u32 is_rd); 


void sde_mdp_set_ot_limit(struct sde_mdp_set_ot_params *params);



void vbif_lock(struct platform_device *parent_pdev);

void vbif_unlock(struct platform_device *parent_pdev);



void sde_mdp_halt_vbif_xin(struct sde_mdp_vbif_halt_params *params);



int sde_mdp_init_vbif(void);

rotator/sde_rotator_debug.c

+0 −21
Original line number Diff line number Diff line
@@ -574,26 +574,6 @@ static ssize_t sde_rot_evtlog_dump_read(struct file *file, char __user *buff, 
	return len;

}



/*

 * sde_rot_evtlog_dump_write - debugfs write handler for evtlog dump

 * @file: file handler

 * @user_buf: user buffer content from debugfs

 * @count: size of user buffer

 * @ppos: position offset of user buffer

 */

static ssize_t sde_rot_evtlog_dump_write(struct file *file,

	const char __user *user_buf, size_t count, loff_t *ppos)

{

	sde_rot_evtlog_dump_all();



	sde_rot_dump_reg_all();



	if (sde_rot_dbg_evtlog.panic_on_err)

		panic("evtlog_dump_write");



	return count;

}



/*

 * sde_rot_evtlog_dump_helper - helper function for evtlog dump

 * @dead: boolean indicates panic after dump
@@ -959,7 +939,6 @@ static int sde_rotator_core_create_debugfs( 
static const struct file_operations sde_rot_evtlog_fops = {

	.open = sde_rot_evtlog_dump_open,

	.read = sde_rot_evtlog_dump_read,

	.write = sde_rot_evtlog_dump_write,

};



static int sde_rotator_evtlog_create_debugfs(

rotator/sde_rotator_r3.c

+84 −17
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ 
#include "sde_rotator_r3_debug.h"

#include "sde_rotator_trace.h"

#include "sde_rotator_debug.h"

#include "sde_rotator_vbif.h"



#define RES_UHD              (3840*2160)

#define MS_TO_US(t) ((t) * USEC_PER_MSEC)
@@ -35,10 +36,6 @@ 
#define TRAFFIC_SHAPE_CLKTICK_12MS   230400

#define TRAFFIC_SHAPE_VSYNC_CLK      19200000



/* XIN mapping */

#define XIN_SSPP		0

#define XIN_WRITEBACK		1



/* wait for at most 2 vsync for lowest refresh rate (24hz) */

#define KOFF_TIMEOUT		(42 * 8)
@@ -748,23 +745,29 @@ static void sde_hw_rotator_disable_irq(struct sde_hw_rotator *rot) 
	}

}



static void sde_hw_rotator_halt_vbif_xin_client(void)

static int sde_hw_rotator_halt_vbif_xin_client(void)

{

	struct sde_mdp_vbif_halt_params halt_params;

	int rc = 0;

	struct sde_rot_data_type *mdata = sde_rot_get_mdata();



	memset(&halt_params, 0, sizeof(struct sde_mdp_vbif_halt_params));

	halt_params.xin_id = XIN_SSPP;

	halt_params.xin_id = mdata->vbif_xin_id[XIN_SSPP];

	halt_params.reg_off_mdp_clk_ctrl = MMSS_VBIF_NRT_VBIF_CLK_FORCE_CTRL0;

	halt_params.bit_off_mdp_clk_ctrl =

		MMSS_VBIF_NRT_VBIF_CLK_FORCE_CTRL0_XIN0;

	sde_mdp_halt_vbif_xin(&halt_params);

	rc |=  halt_params.xin_timeout;



	memset(&halt_params, 0, sizeof(struct sde_mdp_vbif_halt_params));

	halt_params.xin_id = XIN_WRITEBACK;

	halt_params.xin_id = mdata->vbif_xin_id[XIN_WRITEBACK];

	halt_params.reg_off_mdp_clk_ctrl = MMSS_VBIF_NRT_VBIF_CLK_FORCE_CTRL0;

	halt_params.bit_off_mdp_clk_ctrl =

		MMSS_VBIF_NRT_VBIF_CLK_FORCE_CTRL0_XIN1;

	sde_mdp_halt_vbif_xin(&halt_params);

	rc |=  halt_params.xin_timeout;



	return rc;

}



/**
@@ -1025,6 +1028,47 @@ static void sde_hw_rotator_unmap_vaddr(struct sde_dbg_buf *dbgbuf) 
	dbgbuf->height = 0;

}



static void sde_hw_rotator_vbif_rt_setting(void)

{

	u32 reg_high, reg_shift, reg_val, reg_val_lvl, mask, vbif_qos;

	struct sde_rot_data_type *mdata = sde_rot_get_mdata();

	int i, j;



	vbif_lock(mdata->parent_pdev);



	for (i = 0; i < mdata->npriority_lvl; i++) {

		for (j = 0; j < MAX_XIN; j++) {

			reg_high = ((mdata->vbif_xin_id[j]

						& 0x8) >> 3) * 4 + (i * 8);

			reg_shift = mdata->vbif_xin_id[j] * 4;



			reg_val = SDE_VBIF_READ(mdata,

			MMSS_VBIF_NRT_VBIF_QOS_RP_REMAP_000 + reg_high);

			reg_val_lvl = SDE_VBIF_READ(mdata,

			MMSS_VBIF_NRT_VBIF_QOS_LVL_REMAP_000 + reg_high);



			mask = 0x7 << (mdata->vbif_xin_id[j] * 4);



			vbif_qos = mdata->vbif_nrt_qos[i];



			reg_val &= ~mask;

			reg_val |= (vbif_qos << reg_shift) & mask;



			reg_val_lvl &= ~mask;

			reg_val_lvl |= (vbif_qos << reg_shift) & mask;



			SDE_VBIF_WRITE(mdata,

				MMSS_VBIF_NRT_VBIF_QOS_RP_REMAP_000 + reg_high,

					reg_val);

			SDE_VBIF_WRITE(mdata,

				MMSS_VBIF_NRT_VBIF_QOS_LVL_REMAP_000 + reg_high,

					reg_val_lvl);

		}

	}



	vbif_unlock(mdata->parent_pdev);

}



/*

 * sde_hw_rotator_vbif_setting - helper function to set vbif QoS remapper

 * levels, enable write gather enable and avoid clk gating setting for
@@ -2095,7 +2139,10 @@ static u32 sde_hw_rotator_wait_done_regdma( 
					__sde_hw_rotator_get_timestamp(rot,

					ROT_QUEUE_LOW_PRIORITY);



			if (ubwcerr || abort) {

			spin_unlock_irqrestore(&rot->rotisr_lock, flags);



			if (ubwcerr || abort ||

					sde_hw_rotator_halt_vbif_xin_client()) {

				/*

				 * Perform recovery for ROT SSPP UBWC decode

				 * error.
@@ -2103,16 +2150,15 @@ static u32 sde_hw_rotator_wait_done_regdma( 
				 * - reset TS logic so all pending rotation

				 *   in hw queue got done signalled

				 */

				spin_unlock_irqrestore(&rot->rotisr_lock,

						flags);

				if (!sde_hw_rotator_reset(rot, ctx))

					status = REGDMA_INCOMPLETE_CMD;

				else

					status = ROT_ERROR_BIT;

				spin_lock_irqsave(&rot->rotisr_lock, flags);

			} else {

				status = ROT_ERROR_BIT;

			}



			spin_lock_irqsave(&rot->rotisr_lock, flags);

		} else {

			if (rc == 1)

				SDEROT_WARN(
@@ -2829,7 +2875,7 @@ static int sde_hw_rotator_config(struct sde_rot_hw_resource *hw, 
		struct sde_mdp_set_ot_params ot_params;



		memset(&ot_params, 0, sizeof(struct sde_mdp_set_ot_params));

		ot_params.xin_id = XIN_SSPP;

		ot_params.xin_id = mdata->vbif_xin_id[XIN_SSPP];

		ot_params.num = 0; /* not used */

		ot_params.width = entry->perf->config.input.width;

		ot_params.height = entry->perf->config.input.height;
@@ -2851,7 +2897,7 @@ static int sde_hw_rotator_config(struct sde_rot_hw_resource *hw, 
		struct sde_mdp_set_ot_params ot_params;



		memset(&ot_params, 0, sizeof(struct sde_mdp_set_ot_params));

		ot_params.xin_id = XIN_WRITEBACK;

		ot_params.xin_id = mdata->vbif_xin_id[XIN_WRITEBACK];

		ot_params.num = 0; /* not used */

		ot_params.width = entry->perf->config.input.width;

		ot_params.height = entry->perf->config.input.height;
@@ -2872,15 +2918,20 @@ static int sde_hw_rotator_config(struct sde_rot_hw_resource *hw, 
	if (test_bit(SDE_QOS_PER_PIPE_LUT, mdata->sde_qos_map))	{

		u32 qos_lut = 0; /* low priority for nrt read client */



		trace_rot_perf_set_qos_luts(XIN_SSPP, sspp_cfg.fmt->format,

			qos_lut, sde_mdp_is_linear_format(sspp_cfg.fmt));

		trace_rot_perf_set_qos_luts(mdata->vbif_xin_id[XIN_SSPP],

			sspp_cfg.fmt->format, qos_lut,

			sde_mdp_is_linear_format(sspp_cfg.fmt));



		SDE_ROTREG_WRITE(rot->mdss_base, ROT_SSPP_CREQ_LUT, qos_lut);

	}



	/* VBIF QoS and other settings */

	if (!ctx->sbuf_mode)

	if (!ctx->sbuf_mode) {

		if (mdata->parent_pdev)

			sde_hw_rotator_vbif_rt_setting();

		else

			sde_hw_rotator_vbif_setting(rot);

	}



	return 0;
@@ -3178,6 +3229,22 @@ static int sde_rotator_hw_rev_init(struct sde_hw_rotator *rot) 
				ARRAY_SIZE(sde_hw_rotator_v4_outpixfmts_sbuf);

		rot->downscale_caps =

			"LINEAR/1.5/2/4/8/16/32/64 TILE/1.5/2/4 TP10/1.5/2";

	} else if (IS_SDE_MAJOR_MINOR_SAME(mdata->mdss_version,

				SDE_MDP_HW_REV_540)) {

		SDEROT_DBG("Sys cache inline rotation not supported\n");

		set_bit(SDE_CAPS_UBWC_2,  mdata->sde_caps_map);

		set_bit(SDE_CAPS_PARTIALWR,  mdata->sde_caps_map);

		set_bit(SDE_CAPS_HW_TIMESTAMP, mdata->sde_caps_map);

		rot->inpixfmts[SDE_ROTATOR_MODE_OFFLINE] =

				sde_hw_rotator_v4_inpixfmts;

		rot->num_inpixfmt[SDE_ROTATOR_MODE_OFFLINE] =

				ARRAY_SIZE(sde_hw_rotator_v4_inpixfmts);

		rot->outpixfmts[SDE_ROTATOR_MODE_OFFLINE] =

				sde_hw_rotator_v4_outpixfmts;

		rot->num_outpixfmt[SDE_ROTATOR_MODE_OFFLINE] =

				ARRAY_SIZE(sde_hw_rotator_v4_outpixfmts);

		rot->downscale_caps =

			"LINEAR/1.5/2/4/8/16/32/64 TILE/1.5/2/4 TP10/1.5/2";

	} else if (IS_SDE_MAJOR_MINOR_SAME(mdata->mdss_version,

				SDE_MDP_HW_REV_400) ||

			IS_SDE_MAJOR_MINOR_SAME(mdata->mdss_version,