android_kernel_samsung_sm8650-modules/msm/sde/sde_vbif.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved.
 * Copyright (c) 2015-2021, The Linux Foundation. All rights reserved.
 */

#define pr_fmt(fmt)	"[drm:%s:%d] " fmt, __func__, __LINE__

#include <linux/debugfs.h>

#include "sde_vbif.h"
#include "sde_hw_vbif.h"
#include "sde_trace.h"
#include "sde_rotator_vbif.h"

#define MAX_XIN_CLIENT	16

#define VBIF_CLK_CLIENT(x) sde_kms->vbif_clk_clients[x]
#define VBIF_CLK_CLIENT_NAME(x) sde_clk_ctrl_type_s[x]

int sde_vbif_clk_register(struct sde_kms *sde_kms, struct sde_vbif_clk_client *client)
{
	enum sde_clk_ctrl_type clk_ctrl;

	if (!sde_kms || !client)
		return -EINVAL;

	clk_ctrl = client->clk_ctrl;
	if (!SDE_CLK_CTRL_VALID(clk_ctrl))
		return -EINVAL;

	VBIF_CLK_CLIENT(clk_ctrl).hw = client->hw;
	VBIF_CLK_CLIENT(clk_ctrl).clk_ctrl = clk_ctrl;
	memcpy(&VBIF_CLK_CLIENT(clk_ctrl).ops, &client->ops, sizeof(struct sde_vbif_clk_ops));

	SDE_DEBUG("registering hw:%pK clk_ctrl:%s\n", client->hw, VBIF_CLK_CLIENT_NAME(clk_ctrl));

	return 0;
}

/**
 * _sde_vbif_setup_clk_supported - check if VBIF setup_clk_force_ctrl API is supported
 * @sde_kms:	Pointer to sde_kms object
 * @clk_ctrl:	clock to be controlled
 * @return:	true if client is supported, otherwise false
 */
static bool _sde_vbif_setup_clk_supported(struct sde_kms *sde_kms, enum sde_clk_ctrl_type clk_ctrl)
{
	bool supported = false;
	bool has_split_vbif = test_bit(SDE_FEATURE_VBIF_CLK_SPLIT, sde_kms->catalog->features);

	if (!SDE_CLK_CTRL_VALID(clk_ctrl))
		return false;

	if ((has_split_vbif && VBIF_CLK_CLIENT(clk_ctrl).ops.setup_clk_force_ctrl) ||
			(!has_split_vbif && sde_kms->hw_mdp->ops.setup_clk_force_ctrl))
		supported = true;

	SDE_DEBUG("split_vbif:%d type:%s supported:%d\n", has_split_vbif,
			VBIF_CLK_CLIENT_NAME(clk_ctrl), supported);

	return supported;
}

/**
 * _sde_vbif_get_clk_supported - check if VBIF get_clk_ctrl_status API is supported
 * @sde_kms:	Pointer to sde_kms object
 * @clk_ctrl:	clock to be controlled
 * @return:	true if client is supported, otherwise false
 */
static bool _sde_vbif_get_clk_supported(struct sde_kms *sde_kms, enum sde_clk_ctrl_type clk_ctrl)
{
	bool supported = false;
	bool has_split_vbif = test_bit(SDE_FEATURE_VBIF_CLK_SPLIT, sde_kms->catalog->features);

	if ((has_split_vbif && VBIF_CLK_CLIENT(clk_ctrl).ops.get_clk_ctrl_status) ||
			(!has_split_vbif && sde_kms->hw_mdp->ops.get_clk_ctrl_status))
		supported = true;

	SDE_DEBUG("split_vbif:%d type:%s supported:%d\n", has_split_vbif,
			VBIF_CLK_CLIENT_NAME(clk_ctrl), supported);

	return supported;
}

/**
 * _sde_vbif_setup_clk_force_ctrl - set clock force control
 * @sde_kms:	Pointer to sde_kms object
 * @clk_ctrl:	clock to be controlled
 * @enable:	force on enable
 * @return:	if the clock is forced-on by this function
 */
static int _sde_vbif_setup_clk_force_ctrl(struct sde_kms *sde_kms, enum sde_clk_ctrl_type clk_ctrl,
		bool enable)
{
	int rc = 0;
	struct sde_hw_blk_reg_map *hw = VBIF_CLK_CLIENT(clk_ctrl).hw;
	bool has_split_vbif = test_bit(SDE_FEATURE_VBIF_CLK_SPLIT, sde_kms->catalog->features);

	if (has_split_vbif)
		rc = VBIF_CLK_CLIENT(clk_ctrl).ops.setup_clk_force_ctrl(hw, clk_ctrl, enable);
	else
		rc = sde_kms->hw_mdp->ops.setup_clk_force_ctrl(sde_kms->hw_mdp, clk_ctrl, enable);

	SDE_DEBUG("split_vbif:%d type:%s en:%d rc:%d\n", has_split_vbif,
			VBIF_CLK_CLIENT_NAME(clk_ctrl), enable, rc);

	return rc;
}

/**
 * _sde_vbif_get_clk_ctrl_status - get clock control status
 * @sde_kms:	Pointer to sde_kms object
 * @clk_ctrl:	clock to be controlled
 * @status:	returns true if clock is on
 * @return:	0 if success, otherwise return error code
 */
static int _sde_vbif_get_clk_ctrl_status(struct sde_kms *sde_kms, enum sde_clk_ctrl_type clk_ctrl,
		bool *status)
{
	int rc = 0;
	struct sde_hw_blk_reg_map *hw = VBIF_CLK_CLIENT(clk_ctrl).hw;
	bool has_split_vbif = test_bit(SDE_FEATURE_VBIF_CLK_SPLIT, sde_kms->catalog->features);

	if (has_split_vbif)
		rc = VBIF_CLK_CLIENT(clk_ctrl).ops.get_clk_ctrl_status(hw, clk_ctrl, status);
	else
		rc = sde_kms->hw_mdp->ops.get_clk_ctrl_status(sde_kms->hw_mdp, clk_ctrl, status);

	SDE_DEBUG("split_vbif:%d type:%s status:%d rc:%d\n", has_split_vbif,
			VBIF_CLK_CLIENT_NAME(clk_ctrl), *status, rc);

	return rc;
}

/**
 * _sde_vbif_wait_for_xin_halt - wait for the xin to halt
 * @vbif:	Pointer to hardware vbif driver
 * @xin_id:	Client interface identifier
 * @return:	0 if success; error code otherwise
 */
static int _sde_vbif_wait_for_xin_halt(struct sde_hw_vbif *vbif, u32 xin_id)
{
	ktime_t timeout;
	bool status;
	int rc;

	if (!vbif || !vbif->cap || !vbif->ops.get_xin_halt_status) {
		SDE_ERROR("invalid arguments vbif %d\n", !vbif);
		return -EINVAL;
	}

	timeout = ktime_add_us(ktime_get(), vbif->cap->xin_halt_timeout);
	for (;;) {
		status = vbif->ops.get_xin_halt_status(vbif, xin_id);
		if (status)
			break;
		if (ktime_compare_safe(ktime_get(), timeout) > 0) {
			status = vbif->ops.get_xin_halt_status(vbif, xin_id);
			break;
		}
		usleep_range(501, 1000);
	}

	if (!status) {
		rc = -ETIMEDOUT;
		SDE_ERROR("VBIF %d client %d not halting. TIMEDOUT.\n",
				vbif->idx - VBIF_0, xin_id);
	} else {
		rc = 0;
		SDE_DEBUG("VBIF %d client %d is halted\n",
				vbif->idx - VBIF_0, xin_id);
	}

	return rc;
}

static int _sde_vbif_wait_for_axi_halt(struct sde_hw_vbif *vbif)
{
	int rc;

	if (!vbif || !vbif->cap || !vbif->ops.get_axi_halt_status) {
		SDE_ERROR("invalid arguments vbif %d\n", !vbif);
		return -EINVAL;
	}

	rc = vbif->ops.get_axi_halt_status(vbif);
	if (rc)
		SDE_ERROR("VBIF %d AXI port(s) not halting. TIMEDOUT.\n",
				vbif->idx - VBIF_0);
	else
		SDE_DEBUG("VBIF %d AXI port(s) halted\n",
				vbif->idx - VBIF_0);

	return rc;
}

/**
 * _sde_vbif_apply_dynamic_ot_limit - determine OT based on usecase parameters
 * @vbif:	Pointer to hardware vbif driver
 * @ot_lim:	Pointer to OT limit to be modified
 * @params:	Pointer to usecase parameters
 */
static void _sde_vbif_apply_dynamic_ot_limit(struct sde_hw_vbif *vbif,
		u32 *ot_lim, struct sde_vbif_set_ot_params *params)
{
	u64 pps;
	const struct sde_vbif_dynamic_ot_tbl *tbl;
	u32 i;

	if (!vbif || !(vbif->cap->features & BIT(SDE_VBIF_QOS_OTLIM)))
		return;

	/* Dynamic OT setting done only for WFD */
	if (!params->is_wfd)
		return;

	pps = params->frame_rate;
	pps *= params->width;
	pps *= params->height;

	tbl = params->rd ? &vbif->cap->dynamic_ot_rd_tbl :
			&vbif->cap->dynamic_ot_wr_tbl;

	for (i = 0; i < tbl->count; i++) {
		if (pps <= tbl->cfg[i].pps) {
			*ot_lim = tbl->cfg[i].ot_limit;
			break;
		}
	}

	SDE_DEBUG("vbif:%d xin:%d w:%d h:%d fps:%d pps:%llu ot:%u\n",
			vbif->idx - VBIF_0, params->xin_id,
			params->width, params->height, params->frame_rate,
			pps, *ot_lim);
}

/**
 * _sde_vbif_get_ot_limit - get OT based on usecase & configuration parameters
 * @vbif:	Pointer to hardware vbif driver
 * @params:	Pointer to usecase parameters
 * @return:	OT limit
 */
static u32 _sde_vbif_get_ot_limit(struct sde_hw_vbif *vbif,
	struct sde_vbif_set_ot_params *params)
{
	u32 ot_lim = 0;
	u32 val;

	if (!vbif || !vbif->cap) {
		SDE_ERROR("invalid arguments vbif %d\n", !vbif);
		return -EINVAL;
	}

	if (vbif->cap->default_ot_wr_limit && !params->rd)
		ot_lim = vbif->cap->default_ot_wr_limit;
	else if (vbif->cap->default_ot_rd_limit && params->rd)
		ot_lim = vbif->cap->default_ot_rd_limit;

	/*
	 * If default ot is not set from dt/catalog,
	 * then do not configure it.
	 */
	if (ot_lim == 0)
		goto exit;

	/* Modify the limits if the target and the use case requires it */
	_sde_vbif_apply_dynamic_ot_limit(vbif, &ot_lim, params);

	if (vbif && vbif->ops.get_limit_conf) {
		val = vbif->ops.get_limit_conf(vbif,
				params->xin_id, params->rd);
		if (val == ot_lim)
			ot_lim = 0;
	}

exit:
	SDE_DEBUG("vbif:%d xin:%d ot_lim:%d\n",
			vbif->idx - VBIF_0, params->xin_id, ot_lim);
	return ot_lim;
}

/**
 * sde_vbif_set_ot_limit - set OT based on usecase & configuration parameters
 * @vbif:	Pointer to hardware vbif driver
 * @params:	Pointer to usecase parameters
 *
 * Note this function would block waiting for bus halt.
 */
void sde_vbif_set_ot_limit(struct sde_kms *sde_kms,
		struct sde_vbif_set_ot_params *params)
{
	struct sde_hw_vbif *vbif = NULL;
	struct sde_hw_mdp *mdp;
	bool forced_on = false;
	u32 ot_lim;
	int ret, i;

	if (!sde_kms) {
		SDE_ERROR("invalid arguments\n");
		return;
	}

	if (!sde_kms_is_vbif_operation_allowed(sde_kms)) {
		SDE_DEBUG("vbif operations not permitted\n");
		return;
	}

	mdp = sde_kms->hw_mdp;

	for (i = 0; i < ARRAY_SIZE(sde_kms->hw_vbif); i++) {
		if (sde_kms->hw_vbif[i] &&
				sde_kms->hw_vbif[i]->idx == params->vbif_idx) {
			vbif = sde_kms->hw_vbif[i];
			break;
		}
	}

	if (!vbif || !mdp) {
		SDE_DEBUG("invalid arguments vbif %d mdp %d\n",
				vbif != NULL, mdp != NULL);
		return;
	}

	if (!_sde_vbif_setup_clk_supported(sde_kms, params->clk_ctrl) ||
			!vbif->ops.set_limit_conf ||
			!vbif->ops.set_xin_halt)
		return;

	if (test_bit(SDE_FEATURE_EMULATED_ENV, sde_kms->catalog->features))
		return;

	mutex_lock(&vbif->mutex);

	SDE_EVT32_VERBOSE(vbif->idx, params->xin_id);

	/* set write_gather_en for all write clients */
	if (vbif->ops.set_write_gather_en && !params->rd)
		vbif->ops.set_write_gather_en(vbif, params->xin_id);

	ot_lim = _sde_vbif_get_ot_limit(vbif, params) & 0xFF;

	if (ot_lim == 0)
		goto exit;

	trace_sde_perf_set_ot(params->num, params->xin_id, ot_lim,
		params->vbif_idx);

	forced_on = _sde_vbif_setup_clk_force_ctrl(sde_kms, params->clk_ctrl, true);

	vbif->ops.set_limit_conf(vbif, params->xin_id, params->rd, ot_lim);

	vbif->ops.set_xin_halt(vbif, params->xin_id, true);

	ret = _sde_vbif_wait_for_xin_halt(vbif, params->xin_id);
	if (ret)
		SDE_EVT32(vbif->idx, params->xin_id);

	vbif->ops.set_xin_halt(vbif, params->xin_id, false);

	if (forced_on)
		_sde_vbif_setup_clk_force_ctrl(sde_kms, params->clk_ctrl, false);

exit:
	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)
{
	struct sde_hw_vbif *vbif = NULL;
	struct sde_hw_mdp *mdp;
	bool forced_on = false;
	int ret, i;

	if (!sde_kms || !params) {
		SDE_ERROR("invalid arguments\n");
		return false;
	}

	if (!sde_kms_is_vbif_operation_allowed(sde_kms)) {
		SDE_DEBUG("vbif operations not permitted\n");
		return true;
	}

	mdp = sde_kms->hw_mdp;

	for (i = 0; i < ARRAY_SIZE(sde_kms->hw_vbif); i++) {
		if (sde_kms->hw_vbif[i] &&
				sde_kms->hw_vbif[i]->idx == params->vbif_idx) {
			vbif = sde_kms->hw_vbif[i];
			break;
		}
	}

	if (!vbif || !mdp) {
		SDE_DEBUG("invalid arguments vbif %d mdp %d\n",
				vbif != NULL, mdp != NULL);
		return false;
	}

	if (!_sde_vbif_setup_clk_supported(sde_kms, params->clk_ctrl) ||
			!vbif->ops.set_xin_halt)
		return false;

	mutex_lock(&vbif->mutex);

	SDE_EVT32_VERBOSE(vbif->idx, params->xin_id);

	if (params->enable) {
		forced_on = _sde_vbif_setup_clk_force_ctrl(sde_kms, params->clk_ctrl, true);

		vbif->ops.set_xin_halt(vbif, params->xin_id, true);

		ret = _sde_vbif_wait_for_xin_halt(vbif, params->xin_id);
		if (ret)
			SDE_EVT32(vbif->idx, params->xin_id, SDE_EVTLOG_ERROR);
	} else {
		vbif->ops.set_xin_halt(vbif, params->xin_id, false);

		if (params->forced_on)
			_sde_vbif_setup_clk_force_ctrl(sde_kms, params->clk_ctrl, false);
	}

	mutex_unlock(&vbif->mutex);

	return forced_on;
}

bool sde_vbif_get_xin_status(struct sde_kms *sde_kms,
		struct sde_vbif_get_xin_status_params *params)
{
	struct sde_hw_vbif *vbif = NULL;
	struct sde_hw_mdp *mdp;
	int i, rc;
	bool status;

	if (!sde_kms || !params) {
		SDE_ERROR("invalid arguments\n");
		return false;
	}

	if (!sde_kms_is_vbif_operation_allowed(sde_kms)) {
		SDE_DEBUG("vbif operations not permitted\n");
		return true;
	}

	mdp = sde_kms->hw_mdp;

	for (i = 0; i < ARRAY_SIZE(sde_kms->hw_vbif); i++) {
		if (sde_kms->hw_vbif[i] &&
				sde_kms->hw_vbif[i]->idx == params->vbif_idx) {
			vbif = sde_kms->hw_vbif[i];
			break;
		}
	}

	if (!vbif || !mdp) {
		SDE_DEBUG("invalid arguments vbif:%d mdp:%d vbif idx:%d\n",
				vbif != NULL, mdp != NULL, params->vbif_idx);
		return false;
	}

	if (!_sde_vbif_get_clk_supported(sde_kms, params->clk_ctrl) ||
			!vbif->ops.get_xin_halt_status)
		return false;

	mutex_lock(&vbif->mutex);
	SDE_EVT32_VERBOSE(vbif->idx, params->xin_id);
	/* check xin client halt status - true if vbif is idle */
	status = vbif->ops.get_xin_halt_status(vbif, params->xin_id);
	if (status) {
		/* check if client's clk is active - true if clk is active */
		rc = _sde_vbif_get_clk_ctrl_status(sde_kms, params->clk_ctrl, &status);
		status = (rc < 0) ? false : !status;
	}
	mutex_unlock(&vbif->mutex);

	return status;
}

void sde_vbif_set_qos_remap(struct sde_kms *sde_kms,
		struct sde_vbif_set_qos_params *params)
{
	struct sde_hw_vbif *vbif = NULL;
	struct sde_hw_mdp *mdp;
	bool forced_on = false;
	const struct sde_vbif_qos_tbl *qos_tbl;
	int i;
	u32 nlvl;

	if (!sde_kms || !params || !sde_kms->hw_mdp) {
		SDE_ERROR("invalid arguments\n");
		return;
	}

	if (!sde_kms_is_vbif_operation_allowed(sde_kms)) {
		SDE_DEBUG("vbif operations not permitted\n");
		return;
	}

	mdp = sde_kms->hw_mdp;

	for (i = 0; i < ARRAY_SIZE(sde_kms->hw_vbif); i++) {
		if (sde_kms->hw_vbif[i] &&
				sde_kms->hw_vbif[i]->idx == params->vbif_idx) {
			vbif = sde_kms->hw_vbif[i];
			break;
		}
	}

	if (!vbif || !vbif->cap) {
		SDE_ERROR("invalid vbif %d\n", params->vbif_idx);
		return;
	}

	if (!vbif->ops.set_qos_remap || !_sde_vbif_setup_clk_supported(sde_kms, params->clk_ctrl)) {
		SDE_DEBUG("qos remap not supported\n");
		return;
	}

	if (params->client_type > VBIF_MAX_CLIENT) {
		SDE_ERROR("invalid client type:%d\n", params->client_type);
		return;
	}

	qos_tbl = &vbif->cap->qos_tbl[params->client_type];
	if (!qos_tbl->count || !qos_tbl->priority_lvl) {
		SDE_DEBUG("qos tbl not defined\n");
		return;
	}

	mutex_lock(&vbif->mutex);

	forced_on = _sde_vbif_setup_clk_force_ctrl(sde_kms, params->clk_ctrl, true);

	nlvl = qos_tbl->count / 2;
	for (i = 0; i < nlvl; i++) {
		SDE_DEBUG("vbif:%d xin:%d rp_remap:%d/%d, lv_remap:%d/%d\n",
				params->vbif_idx, params->xin_id, i, qos_tbl->priority_lvl[i],
				i + nlvl, qos_tbl->priority_lvl[i + nlvl]);
		vbif->ops.set_qos_remap(vbif, params->xin_id, i,
				qos_tbl->priority_lvl[i], qos_tbl->priority_lvl[i + nlvl]);
	}

	if (forced_on)
		_sde_vbif_setup_clk_force_ctrl(sde_kms, params->clk_ctrl, false);

	mutex_unlock(&vbif->mutex);
}

void sde_vbif_clear_errors(struct sde_kms *sde_kms)
{
	struct sde_hw_vbif *vbif;
	u32 i, pnd, src;

	if (!sde_kms) {
		SDE_ERROR("invalid argument\n");
		return;
	}

	if (!sde_kms_is_vbif_operation_allowed(sde_kms)) {
		SDE_DEBUG("vbif operations not permitted\n");
		return;
	}

	for (i = 0; i < ARRAY_SIZE(sde_kms->hw_vbif); i++) {
		vbif = sde_kms->hw_vbif[i];
		if (vbif && vbif->ops.clear_errors) {
			mutex_lock(&vbif->mutex);
			vbif->ops.clear_errors(vbif, &pnd, &src);
			if (pnd || src) {
				SDE_EVT32(i, pnd, src);
				SDE_DEBUG("VBIF %d: pnd 0x%X, src 0x%X\n",
						vbif->idx - VBIF_0, pnd, src);
			}
			mutex_unlock(&vbif->mutex);
		}
	}
}

void sde_vbif_init_memtypes(struct sde_kms *sde_kms)
{
	struct sde_hw_vbif *vbif;
	int i, j;

	if (!sde_kms) {
		SDE_ERROR("invalid argument\n");
		return;
	}

	if (!sde_kms_is_vbif_operation_allowed(sde_kms)) {
		SDE_DEBUG("vbif operations not permitted\n");
		return;
	}

	for (i = 0; i < ARRAY_SIZE(sde_kms->hw_vbif); i++) {
		vbif = sde_kms->hw_vbif[i];
		if (vbif && vbif->cap && vbif->ops.set_mem_type) {
			mutex_lock(&vbif->mutex);
			for (j = 0; j < vbif->cap->memtype_count; j++)
				vbif->ops.set_mem_type(
						vbif, j, vbif->cap->memtype[j]);
			mutex_unlock(&vbif->mutex);
		}
	}
}

void sde_vbif_axi_halt_request(struct sde_kms *sde_kms)
{
	struct sde_hw_vbif *vbif;
	int i;

	if (!sde_kms) {
		SDE_ERROR("invalid argument\n");
		return;
	}

	if (!sde_kms_is_vbif_operation_allowed(sde_kms)) {
		SDE_DEBUG("vbif operations not permitted\n");
		return;
	}

	if (test_bit(SDE_FEATURE_EMULATED_ENV, sde_kms->catalog->features))
		return;

	for (i = 0; i < ARRAY_SIZE(sde_kms->hw_vbif); i++) {
		vbif = sde_kms->hw_vbif[i];
		if (vbif && vbif->cap && vbif->ops.set_axi_halt) {
			mutex_lock(&vbif->mutex);
			vbif->ops.set_axi_halt(vbif);
			_sde_vbif_wait_for_axi_halt(vbif);
			mutex_unlock(&vbif->mutex);
		}
	}
}

int sde_vbif_halt_xin_mask(struct sde_kms *sde_kms, u32 xin_id_mask,
				bool halt)
{
	struct sde_hw_vbif *vbif;
	int i = 0, status, rc;

	if (!sde_kms) {
		SDE_ERROR("invalid argument\n");
		return -EINVAL;
	}

	vbif = sde_kms->hw_vbif[VBIF_RT];

	if (!vbif->ops.get_xin_halt_status || !vbif->ops.set_xin_halt)
		return 0;

	SDE_EVT32(xin_id_mask, halt);

	for (i = 0; i < MAX_XIN_CLIENT; i++) {
		if (xin_id_mask & BIT(i)) {
			/* unhalt the xin-clients */
			if (!halt) {
				vbif->ops.set_xin_halt(vbif, i, false);
				continue;
			}

			status = vbif->ops.get_xin_halt_status(vbif, i);
			if (status)
				continue;

			/* halt xin-clients and wait for ack */
			vbif->ops.set_xin_halt(vbif, i, true);

			rc = _sde_vbif_wait_for_xin_halt(vbif, i);
			if (rc) {
				SDE_ERROR("xin_halt failed for xin:%d, rc:%d\n",
					i, rc);
				SDE_EVT32(xin_id_mask, i, rc, SDE_EVTLOG_ERROR);
				return rc;
			}
		}
	}

	return 0;
}

#if IS_ENABLED(CONFIG_DEBUG_FS)
void sde_debugfs_vbif_destroy(struct sde_kms *sde_kms)
{
	debugfs_remove_recursive(sde_kms->debugfs_vbif);
	sde_kms->debugfs_vbif = NULL;
}

int sde_debugfs_vbif_init(struct sde_kms *sde_kms, struct dentry *debugfs_root)
{
	char vbif_name[32];
	struct dentry *debugfs_vbif;
	int i, j;

	sde_kms->debugfs_vbif = debugfs_create_dir("vbif", debugfs_root);
	if (!sde_kms->debugfs_vbif) {
		SDE_ERROR("failed to create vbif debugfs\n");
		return -EINVAL;
	}

	for (i = 0; i < sde_kms->catalog->vbif_count; i++) {
		struct sde_vbif_cfg *vbif = &sde_kms->catalog->vbif[i];

		snprintf(vbif_name, sizeof(vbif_name), "%d", vbif->id);

		debugfs_vbif = debugfs_create_dir(vbif_name,
				sde_kms->debugfs_vbif);

		debugfs_create_u32("features", 0400, debugfs_vbif,
			(u32 *)&vbif->features);

		debugfs_create_u32("xin_halt_timeout", 0400, debugfs_vbif,
			(u32 *)&vbif->xin_halt_timeout);

		debugfs_create_u32("default_rd_ot_limit", 0400, debugfs_vbif,
			(u32 *)&vbif->default_ot_rd_limit);

		debugfs_create_u32("default_wr_ot_limit", 0400, debugfs_vbif,
			(u32 *)&vbif->default_ot_wr_limit);

		for (j = 0; j < vbif->dynamic_ot_rd_tbl.count; j++) {
			struct sde_vbif_dynamic_ot_cfg *cfg =
					&vbif->dynamic_ot_rd_tbl.cfg[j];

			snprintf(vbif_name, sizeof(vbif_name),
					"dynamic_ot_rd_%d_pps", j);
			debugfs_create_u64(vbif_name, 0400, debugfs_vbif,
					(u64 *)&cfg->pps);
			snprintf(vbif_name, sizeof(vbif_name),
					"dynamic_ot_rd_%d_ot_limit", j);
			debugfs_create_u32(vbif_name, 0400, debugfs_vbif,
					(u32 *)&cfg->ot_limit);
		}

		for (j = 0; j < vbif->dynamic_ot_wr_tbl.count; j++) {
			struct sde_vbif_dynamic_ot_cfg *cfg =
					&vbif->dynamic_ot_wr_tbl.cfg[j];

			snprintf(vbif_name, sizeof(vbif_name),
					"dynamic_ot_wr_%d_pps", j);
			debugfs_create_u64(vbif_name, 0400, debugfs_vbif,
					(u64 *)&cfg->pps);
			snprintf(vbif_name, sizeof(vbif_name),
					"dynamic_ot_wr_%d_ot_limit", j);
			debugfs_create_u32(vbif_name, 0400, debugfs_vbif,
					(u32 *)&cfg->ot_limit);
		}
	}

	return 0;
}
#endif /* CONFIG_DEBUG_FS */