| /* 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 */ |