path: root/drivers/ram/k3-j721e/lpddr4_sanity.h

/* SPDX-License-Identifier: BSD-3-Clause */
/**********************************************************************
 * Copyright (C) 2012-2019 Cadence Design Systems, Inc.
 **********************************************************************
 * WARNING: This file is auto-generated using api-generator utility.
 *          api-generator: 12.02.13bb8d5
 *          Do not edit it manually.
 **********************************************************************
 * Cadence Core Driver for LPDDR4.
 **********************************************************************
 */

/**
 * This file contains sanity API functions. The purpose of sanity functions
 * is to check input parameters validity. They take the same parameters as
 * original API functions and return 0 on success or EINVAL on wrong parameter
 * value(s).
 */

#ifndef LPDDR4_SANITY_H
#define LPDDR4_SANITY_H

#include <errno.h>
#include <linux/types.h>
#include "lpddr4_if.h"

#define CDN_EOK             0U      /* no error */

static inline uint32_t lpddr4_configsf(const lpddr4_config *obj);
static inline uint32_t lpddr4_privatedatasf(const lpddr4_privatedata *obj);
static inline uint32_t lpddr4_reginitdatasf(const lpddr4_reginitdata *obj);

static inline uint32_t lpddr4_sanityfunction1(const lpddr4_config* config, const uint16_t* configsize);
static inline uint32_t lpddr4_sanityfunction2(const lpddr4_privatedata* pd, const lpddr4_config* cfg);
static inline uint32_t lpddr4_sanityfunction3(const lpddr4_privatedata* pd);
static inline uint32_t lpddr4_sanityfunction4(const lpddr4_privatedata* pd, const lpddr4_regblock cpp, const uint32_t* regvalue);
static inline uint32_t lpddr4_sanityfunction5(const lpddr4_privatedata* pd, const lpddr4_regblock cpp);
static inline uint32_t lpddr4_sanityfunction6(const lpddr4_privatedata* pd, const uint64_t* mmrvalue, const uint8_t* mmrstatus);
static inline uint32_t lpddr4_sanityfunction7(const lpddr4_privatedata* pd, const uint8_t* mrwstatus);
static inline uint32_t lpddr4_sanityfunction8(const lpddr4_privatedata* pd, const lpddr4_reginitdata* regvalues);
static inline uint32_t lpddr4_sanityfunction11(const lpddr4_privatedata* pd, const lpddr4_reginitdata* regvalues);
static inline uint32_t lpddr4_sanityfunction14(const lpddr4_privatedata* pd, const uint64_t* mask);
static inline uint32_t lpddr4_sanityfunction15(const lpddr4_privatedata* pd, const uint64_t* mask);
static inline uint32_t lpddr4_sanityfunction16(const lpddr4_privatedata* pd, const lpddr4_ctlinterrupt intr, const bool* irqstatus);
static inline uint32_t lpddr4_sanityfunction17(const lpddr4_privatedata* pd, const lpddr4_ctlinterrupt intr);
static inline uint32_t lpddr4_sanityfunction18(const lpddr4_privatedata* pd, const uint32_t* mask);
static inline uint32_t lpddr4_sanityfunction20(const lpddr4_privatedata* pd, const lpddr4_phyindepinterrupt intr, const bool* irqstatus);
static inline uint32_t lpddr4_sanityfunction21(const lpddr4_privatedata* pd, const lpddr4_phyindepinterrupt intr);
static inline uint32_t lpddr4_sanityfunction22(const lpddr4_privatedata* pd, const lpddr4_debuginfo* debuginfo);
static inline uint32_t lpddr4_sanityfunction23(const lpddr4_privatedata* pd, const lpddr4_lpiwakeupparam* lpiwakeupparam, const lpddr4_ctlfspnum* fspnum, const uint32_t* cycles);
static inline uint32_t lpddr4_sanityfunction25(const lpddr4_privatedata* pd, const lpddr4_eccenable* eccparam);
static inline uint32_t lpddr4_sanityfunction26(const lpddr4_privatedata* pd, const lpddr4_eccenable* eccparam);
static inline uint32_t lpddr4_sanityfunction27(const lpddr4_privatedata* pd, const lpddr4_reducmode* mode);
static inline uint32_t lpddr4_sanityfunction28(const lpddr4_privatedata* pd, const lpddr4_reducmode* mode);
static inline uint32_t lpddr4_sanityfunction29(const lpddr4_privatedata* pd, const bool* on_off);
static inline uint32_t lpddr4_sanityfunction31(const lpddr4_privatedata* pd, const lpddr4_dbimode* mode);
static inline uint32_t lpddr4_sanityfunction32(const lpddr4_privatedata* pd, const lpddr4_ctlfspnum* fspnum, const uint32_t* cycles);

#define lpddr4_probesf lpddr4_sanityfunction1
#define lpddr4_initsf lpddr4_sanityfunction2
#define lpddr4_startsf lpddr4_sanityfunction3
#define lpddr4_readregsf lpddr4_sanityfunction4
#define lpddr4_writeregsf lpddr4_sanityfunction5
#define lpddr4_getmmrregistersf lpddr4_sanityfunction6
#define lpddr4_setmmrregistersf lpddr4_sanityfunction7
#define lpddr4_writectlconfigsf lpddr4_sanityfunction8
#define lpddr4_writephyconfigsf lpddr4_sanityfunction8
#define lpddr4_writephyindepconfigsf lpddr4_sanityfunction8
#define lpddr4_readctlconfigsf lpddr4_sanityfunction11
#define lpddr4_readphyconfigsf lpddr4_sanityfunction11
#define lpddr4_readphyindepconfigsf lpddr4_sanityfunction11
#define lpddr4_getctlinterruptmasksf lpddr4_sanityfunction14
#define lpddr4_setctlinterruptmasksf lpddr4_sanityfunction15
#define lpddr4_checkctlinterruptsf lpddr4_sanityfunction16
#define lpddr4_ackctlinterruptsf lpddr4_sanityfunction17
#define lpddr4_getphyindepinterruptmsf lpddr4_sanityfunction18
#define lpddr4_setphyindepinterruptmsf lpddr4_sanityfunction18
#define lpddr4_checkphyindepinterrupsf lpddr4_sanityfunction20
#define lpddr4_ackphyindepinterruptsf lpddr4_sanityfunction21
#define lpddr4_getdebuginitinfosf lpddr4_sanityfunction22
#define lpddr4_getlpiwakeuptimesf lpddr4_sanityfunction23
#define lpddr4_setlpiwakeuptimesf lpddr4_sanityfunction23
#define lpddr4_geteccenablesf lpddr4_sanityfunction25
#define lpddr4_seteccenablesf lpddr4_sanityfunction26
#define lpddr4_getreducmodesf lpddr4_sanityfunction27
#define lpddr4_setreducmodesf lpddr4_sanityfunction28
#define lpddr4_getdbireadmodesf lpddr4_sanityfunction29
#define lpddr4_getdbiwritemodesf lpddr4_sanityfunction29
#define lpddr4_setdbimodesf lpddr4_sanityfunction31
#define lpddr4_getrefreshratesf lpddr4_sanityfunction32
#define lpddr4_setrefreshratesf lpddr4_sanityfunction32
#define lpddr4_refreshperchipselectsf lpddr4_sanityfunction3

/**
 * Function to validate struct Config
 *
 * @param[in] obj pointer to struct to be verified
 * @returns 0 for valid
 * @returns EINVAL for invalid
 */
static inline uint32_t lpddr4_configsf(const lpddr4_config *obj)
{
	uint32_t ret = 0;

	if (obj == NULL)
	{
		ret = EINVAL;
	}

	return ret;
}

/**
 * Function to validate struct PrivateData
 *
 * @param[in] obj pointer to struct to be verified
 * @returns 0 for valid
 * @returns EINVAL for invalid
 */
static inline uint32_t lpddr4_privatedatasf(const lpddr4_privatedata *obj)
{
	uint32_t ret = 0;

	if (obj == NULL)
	{
		ret = EINVAL;
	}

	return ret;
}

/**
 * Function to validate struct RegInitData
 *
 * @param[in] obj pointer to struct to be verified
 * @returns 0 for valid
 * @returns EINVAL for invalid
 */
static inline uint32_t lpddr4_reginitdatasf(const lpddr4_reginitdata *obj)
{
	uint32_t ret = 0;

	if (obj == NULL)
	{
		ret = EINVAL;
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] config Driver/hardware configuration required.
 * @param[out] configSize Size of memory allocations required.
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction1(const lpddr4_config* config, const uint16_t* configsize)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (configsize == NULL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_configsf(config) == EINVAL)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[in] cfg Specifies driver/hardware configuration.
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction2(const lpddr4_privatedata* pd, const lpddr4_config* cfg)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_configsf(cfg) == EINVAL)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction3(const lpddr4_privatedata* pd)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[in] cpp Indicates whether controller, PHY or PHY Independent Module register
 * @param[out] regValue Register value read
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction4(const lpddr4_privatedata* pd, const lpddr4_regblock cpp, const uint32_t* regvalue)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (regvalue == NULL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else if (
		(cpp != LPDDR4_CTL_REGS) &&
		(cpp != LPDDR4_PHY_REGS) &&
		(cpp != LPDDR4_PHY_INDEP_REGS)
		)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[in] cpp Indicates whether controller, PHY or PHY Independent Module register
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction5(const lpddr4_privatedata* pd, const lpddr4_regblock cpp)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else if (
		(cpp != LPDDR4_CTL_REGS) &&
		(cpp != LPDDR4_PHY_REGS) &&
		(cpp != LPDDR4_PHY_INDEP_REGS)
		)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[out] mmrValue Value which is read from memory mode register(mmr) for all devices.
 * @param[out] mmrStatus Status of mode register read(mrr) instruction.
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction6(const lpddr4_privatedata* pd, const uint64_t* mmrvalue, const uint8_t* mmrstatus)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (mmrvalue == NULL)
	{
		ret = EINVAL;
	}
	else if (mmrstatus == NULL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[out] mrwStatus Status of mode register write(mrw) instruction.
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction7(const lpddr4_privatedata* pd, const uint8_t* mrwstatus)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (mrwstatus == NULL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[in] regValues Register values to be written
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction8(const lpddr4_privatedata* pd, const lpddr4_reginitdata* regvalues)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_reginitdatasf(regvalues) == EINVAL)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[out] regValues Register values which are read
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction11(const lpddr4_privatedata* pd, const lpddr4_reginitdata* regvalues)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (regvalues == NULL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[out] mask Value of interrupt mask
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction14(const lpddr4_privatedata* pd, const uint64_t* mask)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (mask == NULL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[in] mask Value of interrupt mask to be written
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction15(const lpddr4_privatedata* pd, const uint64_t* mask)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (mask == NULL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[in] intr Interrupt to be checked
 * @param[out] irqStatus Status of the interrupt, TRUE if active
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction16(const lpddr4_privatedata* pd, const lpddr4_ctlinterrupt intr, const bool* irqstatus)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (irqstatus == NULL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else if (
		(intr != LPDDR4_RESET_DONE) &&
		(intr != LPDDR4_BUS_ACCESS_ERROR) &&
		(intr != LPDDR4_MULTIPLE_BUS_ACCESS_ERROR) &&
		(intr != LPDDR4_ECC_MULTIPLE_CORR_ERROR) &&
		(intr != LPDDR4_ECC_MULTIPLE_UNCORR_ERROR) &&
		(intr != LPDDR4_ECC_WRITEBACK_EXEC_ERROR) &&
		(intr != LPDDR4_ECC_SCRUB_DONE) &&
		(intr != LPDDR4_ECC_SCRUB_ERROR) &&
		(intr != LPDDR4_PORT_COMMAND_ERROR) &&
		(intr != LPDDR4_MC_INIT_DONE) &&
		(intr != LPDDR4_LP_DONE) &&
		(intr != LPDDR4_BIST_DONE) &&
		(intr != LPDDR4_WRAP_ERROR) &&
		(intr != LPDDR4_INVALID_BURST_ERROR) &&
		(intr != LPDDR4_RDLVL_ERROR) &&
		(intr != LPDDR4_RDLVL_GATE_ERROR) &&
		(intr != LPDDR4_WRLVL_ERROR) &&
		(intr != LPDDR4_CA_TRAINING_ERROR) &&
		(intr != LPDDR4_DFI_UPDATE_ERROR) &&
		(intr != LPDDR4_MRR_ERROR) &&
		(intr != LPDDR4_PHY_MASTER_ERROR) &&
		(intr != LPDDR4_WRLVL_REQ) &&
		(intr != LPDDR4_RDLVL_REQ) &&
		(intr != LPDDR4_RDLVL_GATE_REQ) &&
		(intr != LPDDR4_CA_TRAINING_REQ) &&
		(intr != LPDDR4_LEVELING_DONE) &&
		(intr != LPDDR4_PHY_ERROR) &&
		(intr != LPDDR4_MR_READ_DONE) &&
		(intr != LPDDR4_TEMP_CHANGE) &&
		(intr != LPDDR4_TEMP_ALERT) &&
		(intr != LPDDR4_SW_DQS_COMPLETE) &&
		(intr != LPDDR4_DQS_OSC_BV_UPDATED) &&
		(intr != LPDDR4_DQS_OSC_OVERFLOW) &&
		(intr != LPDDR4_DQS_OSC_VAR_OUT) &&
		(intr != LPDDR4_MR_WRITE_DONE) &&
		(intr != LPDDR4_INHIBIT_DRAM_DONE) &&
		(intr != LPDDR4_DFI_INIT_STATE) &&
		(intr != LPDDR4_DLL_RESYNC_DONE) &&
		(intr != LPDDR4_TDFI_TO) &&
		(intr != LPDDR4_DFS_DONE) &&
		(intr != LPDDR4_DFS_STATUS) &&
		(intr != LPDDR4_REFRESH_STATUS) &&
		(intr != LPDDR4_ZQ_STATUS) &&
		(intr != LPDDR4_SW_REQ_MODE) &&
		(intr != LPDDR4_LOR_BITS)
		)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[in] intr Interrupt to be acknowledged
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction17(const lpddr4_privatedata* pd, const lpddr4_ctlinterrupt intr)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else if (
		(intr != LPDDR4_RESET_DONE) &&
		(intr != LPDDR4_BUS_ACCESS_ERROR) &&
		(intr != LPDDR4_MULTIPLE_BUS_ACCESS_ERROR) &&
		(intr != LPDDR4_ECC_MULTIPLE_CORR_ERROR) &&
		(intr != LPDDR4_ECC_MULTIPLE_UNCORR_ERROR) &&
		(intr != LPDDR4_ECC_WRITEBACK_EXEC_ERROR) &&
		(intr != LPDDR4_ECC_SCRUB_DONE) &&
		(intr != LPDDR4_ECC_SCRUB_ERROR) &&
		(intr != LPDDR4_PORT_COMMAND_ERROR) &&
		(intr != LPDDR4_MC_INIT_DONE) &&
		(intr != LPDDR4_LP_DONE) &&
		(intr != LPDDR4_BIST_DONE) &&
		(intr != LPDDR4_WRAP_ERROR) &&
		(intr != LPDDR4_INVALID_BURST_ERROR) &&
		(intr != LPDDR4_RDLVL_ERROR) &&
		(intr != LPDDR4_RDLVL_GATE_ERROR) &&
		(intr != LPDDR4_WRLVL_ERROR) &&
		(intr != LPDDR4_CA_TRAINING_ERROR) &&
		(intr != LPDDR4_DFI_UPDATE_ERROR) &&
		(intr != LPDDR4_MRR_ERROR) &&
		(intr != LPDDR4_PHY_MASTER_ERROR) &&
		(intr != LPDDR4_WRLVL_REQ) &&
		(intr != LPDDR4_RDLVL_REQ) &&
		(intr != LPDDR4_RDLVL_GATE_REQ) &&
		(intr != LPDDR4_CA_TRAINING_REQ) &&
		(intr != LPDDR4_LEVELING_DONE) &&
		(intr != LPDDR4_PHY_ERROR) &&
		(intr != LPDDR4_MR_READ_DONE) &&
		(intr != LPDDR4_TEMP_CHANGE) &&
		(intr != LPDDR4_TEMP_ALERT) &&
		(intr != LPDDR4_SW_DQS_COMPLETE) &&
		(intr != LPDDR4_DQS_OSC_BV_UPDATED) &&
		(intr != LPDDR4_DQS_OSC_OVERFLOW) &&
		(intr != LPDDR4_DQS_OSC_VAR_OUT) &&
		(intr != LPDDR4_MR_WRITE_DONE) &&
		(intr != LPDDR4_INHIBIT_DRAM_DONE) &&
		(intr != LPDDR4_DFI_INIT_STATE) &&
		(intr != LPDDR4_DLL_RESYNC_DONE) &&
		(intr != LPDDR4_TDFI_TO) &&
		(intr != LPDDR4_DFS_DONE) &&
		(intr != LPDDR4_DFS_STATUS) &&
		(intr != LPDDR4_REFRESH_STATUS) &&
		(intr != LPDDR4_ZQ_STATUS) &&
		(intr != LPDDR4_SW_REQ_MODE) &&
		(intr != LPDDR4_LOR_BITS)
		)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[out] mask Value of interrupt mask
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction18(const lpddr4_privatedata* pd, const uint32_t* mask)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (mask == NULL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[in] intr Interrupt to be checked
 * @param[out] irqStatus Status of the interrupt, TRUE if active
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction20(const lpddr4_privatedata* pd, const lpddr4_phyindepinterrupt intr, const bool* irqstatus)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (irqstatus == NULL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else if (
		(intr != LPDDR4_PHY_INDEP_INIT_DONE_BIT) &&
		(intr != LPDDR4_PHY_INDEP_CONTROL_ERROR_BIT) &&
		(intr != LPDDR4_PHY_INDEP_CA_PARITY_ERR_BIT) &&
		(intr != LPDDR4_PHY_INDEP_RDLVL_ERROR_BIT) &&
		(intr != LPDDR4_PHY_INDEP_RDLVL_GATE_ERROR_BIT) &&
		(intr != LPDDR4_PHY_INDEP_WRLVL_ERROR_BIT) &&
		(intr != LPDDR4_PHY_INDEP_CALVL_ERROR_BIT) &&
		(intr != LPDDR4_PHY_INDEP_WDQLVL_ERROR_BIT) &&
		(intr != LPDDR4_PHY_INDEP_UPDATE_ERROR_BIT) &&
		(intr != LPDDR4_PHY_INDEP_RDLVL_REQ_BIT) &&
		(intr != LPDDR4_PHY_INDEP_RDLVL_GATE_REQ_BIT) &&
		(intr != LPDDR4_PHY_INDEP_WRLVL_REQ_BIT) &&
		(intr != LPDDR4_PHY_INDEP_CALVL_REQ_BIT) &&
		(intr != LPDDR4_PHY_INDEP_WDQLVL_REQ_BIT) &&
		(intr != LPDDR4_PHY_INDEP_LVL_DONE_BIT) &&
		(intr != LPDDR4_PHY_INDEP_BIST_DONE_BIT) &&
		(intr != LPDDR4_PHY_INDEP_TDFI_INIT_TIME_OUT_BIT) &&
		(intr != LPDDR4_PHY_INDEP_DLL_LOCK_STATE_CHANGE_BIT)
		)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[in] intr Interrupt to be acknowledged
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction21(const lpddr4_privatedata* pd, const lpddr4_phyindepinterrupt intr)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else if (
		(intr != LPDDR4_PHY_INDEP_INIT_DONE_BIT) &&
		(intr != LPDDR4_PHY_INDEP_CONTROL_ERROR_BIT) &&
		(intr != LPDDR4_PHY_INDEP_CA_PARITY_ERR_BIT) &&
		(intr != LPDDR4_PHY_INDEP_RDLVL_ERROR_BIT) &&
		(intr != LPDDR4_PHY_INDEP_RDLVL_GATE_ERROR_BIT) &&
		(intr != LPDDR4_PHY_INDEP_WRLVL_ERROR_BIT) &&
		(intr != LPDDR4_PHY_INDEP_CALVL_ERROR_BIT) &&
		(intr != LPDDR4_PHY_INDEP_WDQLVL_ERROR_BIT) &&
		(intr != LPDDR4_PHY_INDEP_UPDATE_ERROR_BIT) &&
		(intr != LPDDR4_PHY_INDEP_RDLVL_REQ_BIT) &&
		(intr != LPDDR4_PHY_INDEP_RDLVL_GATE_REQ_BIT) &&
		(intr != LPDDR4_PHY_INDEP_WRLVL_REQ_BIT) &&
		(intr != LPDDR4_PHY_INDEP_CALVL_REQ_BIT) &&
		(intr != LPDDR4_PHY_INDEP_WDQLVL_REQ_BIT) &&
		(intr != LPDDR4_PHY_INDEP_LVL_DONE_BIT) &&
		(intr != LPDDR4_PHY_INDEP_BIST_DONE_BIT) &&
		(intr != LPDDR4_PHY_INDEP_TDFI_INIT_TIME_OUT_BIT) &&
		(intr != LPDDR4_PHY_INDEP_DLL_LOCK_STATE_CHANGE_BIT)
		)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[out] debugInfo status
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction22(const lpddr4_privatedata* pd, const lpddr4_debuginfo* debuginfo)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (debuginfo == NULL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[in] lpiWakeUpParam LPI timing parameter
 * @param[in] fspNum Frequency copy
 * @param[out] cycles Timing value(in cycles)
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction23(const lpddr4_privatedata* pd, const lpddr4_lpiwakeupparam* lpiwakeupparam, const lpddr4_ctlfspnum* fspnum, const uint32_t* cycles)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (lpiwakeupparam == NULL)
	{
		ret = EINVAL;
	}
	else if (fspnum == NULL)
	{
		ret = EINVAL;
	}
	else if (cycles == NULL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else if (
		(*lpiwakeupparam != LPDDR4_LPI_PD_WAKEUP_FN) &&
		(*lpiwakeupparam != LPDDR4_LPI_SR_SHORT_WAKEUP_FN) &&
		(*lpiwakeupparam != LPDDR4_LPI_SR_LONG_WAKEUP_FN) &&
		(*lpiwakeupparam != LPDDR4_LPI_SR_LONG_MCCLK_GATE_WAKEUP_FN) &&
		(*lpiwakeupparam != LPDDR4_LPI_SRPD_SHORT_WAKEUP_FN) &&
		(*lpiwakeupparam != LPDDR4_LPI_SRPD_LONG_WAKEUP_FN) &&
		(*lpiwakeupparam != LPDDR4_LPI_SRPD_LONG_MCCLK_GATE_WAKEUP_FN)
		)
	{
		ret = EINVAL;
	}
	else if (
		(*fspnum != LPDDR4_FSP_0) &&
		(*fspnum != LPDDR4_FSP_1) &&
		(*fspnum != LPDDR4_FSP_2)
		)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[out] eccParam ECC parameter setting
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction25(const lpddr4_privatedata* pd, const lpddr4_eccenable* eccparam)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (eccparam == NULL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[in] eccParam ECC control parameter setting
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction26(const lpddr4_privatedata* pd, const lpddr4_eccenable* eccparam)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (eccparam == NULL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else if (
		(*eccparam != LPDDR4_ECC_DISABLED) &&
		(*eccparam != LPDDR4_ECC_ENABLED) &&
		(*eccparam != LPDDR4_ECC_ERR_DETECT) &&
		(*eccparam != LPDDR4_ECC_ERR_DETECT_CORRECT)
		)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[out] mode Half Datapath setting
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction27(const lpddr4_privatedata* pd, const lpddr4_reducmode* mode)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (mode == NULL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[in] mode Half Datapath setting
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction28(const lpddr4_privatedata* pd, const lpddr4_reducmode* mode)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (mode == NULL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else if (
		(*mode != LPDDR4_REDUC_ON) &&
		(*mode != LPDDR4_REDUC_OFF)
		)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[out] on_off DBI read value
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction29(const lpddr4_privatedata* pd, const bool* on_off)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (on_off == NULL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[in] mode status
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction31(const lpddr4_privatedata* pd, const lpddr4_dbimode* mode)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (mode == NULL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else if (
		(*mode != LPDDR4_DBI_RD_ON) &&
		(*mode != LPDDR4_DBI_RD_OFF) &&
		(*mode != LPDDR4_DBI_WR_ON) &&
		(*mode != LPDDR4_DBI_WR_OFF)
		)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

/**
 * A common function to check the validity of API functions with
 * following parameter types
 * @param[in] pD Driver state info specific to this instance.
 * @param[in] fspNum Frequency set number
 * @param[out] cycles Refresh rate (in cycles)
 * @return 0 success
 * @return EINVAL invalid parameters
 */
static inline uint32_t lpddr4_sanityfunction32(const lpddr4_privatedata* pd, const lpddr4_ctlfspnum* fspnum, const uint32_t* cycles)
{
	/* Declaring return variable */
	uint32_t ret = 0;

	if (fspnum == NULL)
	{
		ret = EINVAL;
	}
	else if (cycles == NULL)
	{
		ret = EINVAL;
	}
	else if (lpddr4_privatedatasf(pd) == EINVAL)
	{
		ret = EINVAL;
	}
	else if (
		(*fspnum != LPDDR4_FSP_0) &&
		(*fspnum != LPDDR4_FSP_1) &&
		(*fspnum != LPDDR4_FSP_2)
		)
	{
		ret = EINVAL;
	}
	else
	{
		/*
		 * All 'if ... else if' constructs shall be terminated with an 'else' statement
		 * (MISRA2012-RULE-15_7-3)
		 */
	}

	return ret;
}

#endif  /* LPDDR4_SANITY_H */