/*****************************************************************************
* Copyright 2003 - 2008 Broadcom Corporation.  All rights reserved.
*
* Unless you and Broadcom execute a separate written software license
* agreement governing use of this software, this software is licensed to you
* under the terms of the GNU General Public License version 2, available at
* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
*
* Notwithstanding the above, under no circumstances may you combine this
* software in any way with any other Broadcom software provided under a
* license other than the GPL, without Broadcom's express prior written
* consent.
*****************************************************************************/

#ifndef CHIPC_INLINE_H
#define CHIPC_INLINE_H

/* ---- Include Files ----------------------------------------------------- */

#include <csp/errno.h>
#include <csp/reg.h>
#include <mach/csp/chipcHw_reg.h>
#include <mach/csp/chipcHw_def.h>

/* ---- Private Constants and Types --------------------------------------- */
typedef enum {
	chipcHw_OPTYPE_BYPASS,	/* Bypass operation */
	chipcHw_OPTYPE_OUTPUT	/* Output operation */
} chipcHw_OPTYPE_e;

/* ---- Public Constants and Types ---------------------------------------- */
/* ---- Public Variable Externs ------------------------------------------- */
/* ---- Public Function Prototypes ---------------------------------------- */
/* ---- Private Function Prototypes --------------------------------------- */
static inline void chipcHw_setClock(chipcHw_CLOCK_e clock,
				    chipcHw_OPTYPE_e type, int mode);

/****************************************************************************/
/**
*  @brief   Get Numeric Chip ID
*
*  This function returns Chip ID that includes the revison number
*
*  @return  Complete numeric Chip ID
*
*/
/****************************************************************************/
static inline uint32_t chipcHw_getChipId(void)
{
	return pChipcHw->ChipId;
}

/****************************************************************************/
/**
*  @brief   Enable Spread Spectrum
*
*  @note chipcHw_Init() must be called earlier
*/
/****************************************************************************/
static inline void chipcHw_enableSpreadSpectrum(void)
{
	if ((pChipcHw->
	     PLLPreDivider & chipcHw_REG_PLL_PREDIVIDER_NDIV_MODE_MASK) !=
	    chipcHw_REG_PLL_PREDIVIDER_NDIV_MODE_INTEGER) {
		ddrcReg_PHY_ADDR_CTL_REGP->ssCfg =
		    (0xFFFF << ddrcReg_PHY_ADDR_SS_CFG_NDIV_AMPLITUDE_SHIFT) |
		    (ddrcReg_PHY_ADDR_SS_CFG_MIN_CYCLE_PER_TICK <<
		     ddrcReg_PHY_ADDR_SS_CFG_CYCLE_PER_TICK_SHIFT);
		ddrcReg_PHY_ADDR_CTL_REGP->ssCtl |=
		    ddrcReg_PHY_ADDR_SS_CTRL_ENABLE;
	}
}

/****************************************************************************/
/**
*  @brief   Disable Spread Spectrum
*
*/
/****************************************************************************/
static inline void chipcHw_disableSpreadSpectrum(void)
{
	ddrcReg_PHY_ADDR_CTL_REGP->ssCtl &= ~ddrcReg_PHY_ADDR_SS_CTRL_ENABLE;
}

/****************************************************************************/
/**
*  @brief   Get Chip Product ID
*
*  This function returns Chip Product ID
*
*  @return  Chip Product ID
*/
/****************************************************************************/
static inline uint32_t chipcHw_getChipProductId(void)
{
	return (pChipcHw->
		 ChipId & chipcHw_REG_CHIPID_BASE_MASK) >>
		chipcHw_REG_CHIPID_BASE_SHIFT;
}

/****************************************************************************/
/**
*  @brief   Get revision number
*
*  This function returns revision number of the chip
*
*  @return  Revision number
*/
/****************************************************************************/
static inline chipcHw_REV_NUMBER_e chipcHw_getChipRevisionNumber(void)
{
	return pChipcHw->ChipId & chipcHw_REG_CHIPID_REV_MASK;
}

/****************************************************************************/
/**
*  @brief   Enables bus interface clock
*
*  Enables  bus interface clock of various device
*
*  @return  void
*
*  @note    use chipcHw_REG_BUS_CLOCK_XXXX for mask
*/
/****************************************************************************/
static inline void chipcHw_busInterfaceClockEnable(uint32_t mask)
{
	reg32_modify_or(&pChipcHw->BusIntfClock, mask);
}

/****************************************************************************/
/**
*  @brief   Disables bus interface clock
*
*  Disables  bus interface clock of various device
*
*  @return  void
*
*  @note    use chipcHw_REG_BUS_CLOCK_XXXX
*/
/****************************************************************************/
static inline void chipcHw_busInterfaceClockDisable(uint32_t mask)
{
	reg32_modify_and(&pChipcHw->BusIntfClock, ~mask);
}

/****************************************************************************/
/**
*  @brief   Get status (enabled/disabled) of bus interface clock
*
*  This function returns the status of devices' bus interface clock
*
*  @return  Bus interface clock
*
*/
/****************************************************************************/
static inline uint32_t chipcHw_getBusInterfaceClockStatus(void)
{
	return pChipcHw->BusIntfClock;
}

/****************************************************************************/
/**
*  @brief   Enables various audio channels
*
*  Enables audio channel
*
*  @return  void
*
*  @note    use chipcHw_REG_AUDIO_CHANNEL_XXXXXX
*/
/****************************************************************************/
static inline void chipcHw_audioChannelEnable(uint32_t mask)
{
	reg32_modify_or(&pChipcHw->AudioEnable, mask);
}

/****************************************************************************/
/**
*  @brief   Disables various audio channels
*
*  Disables audio channel
*
*  @return  void
*
*  @note    use chipcHw_REG_AUDIO_CHANNEL_XXXXXX
*/
/****************************************************************************/
static inline void chipcHw_audioChannelDisable(uint32_t mask)
{
	reg32_modify_and(&pChipcHw->AudioEnable, ~mask);
}

/****************************************************************************/
/**
*  @brief    Soft resets devices
*
*  Soft resets various devices
*
*  @return   void
*
*  @note     use chipcHw_REG_SOFT_RESET_XXXXXX defines
*/
/****************************************************************************/
static inline void chipcHw_softReset(uint64_t mask)
{
	chipcHw_softResetEnable(mask);
	chipcHw_softResetDisable(mask);
}

static inline void chipcHw_softResetDisable(uint64_t mask)
{
	uint32_t ctrl1 = (uint32_t) mask;
	uint32_t ctrl2 = (uint32_t) (mask >> 32);

	/* Deassert module soft reset */
	REG_LOCAL_IRQ_SAVE;
	pChipcHw->SoftReset1 ^= ctrl1;
	pChipcHw->SoftReset2 ^= (ctrl2 & (~chipcHw_REG_SOFT_RESET_UNHOLD_MASK));
	REG_LOCAL_IRQ_RESTORE;
}

static inline void chipcHw_softResetEnable(uint64_t mask)
{
	uint32_t ctrl1 = (uint32_t) mask;
	uint32_t ctrl2 = (uint32_t) (mask >> 32);
	uint32_t unhold = 0;

	REG_LOCAL_IRQ_SAVE;
	pChipcHw->SoftReset1 |= ctrl1;
	/* Mask out unhold request bits */
	pChipcHw->SoftReset2 |= (ctrl2 & (~chipcHw_REG_SOFT_RESET_UNHOLD_MASK));

	/* Process unhold requests */
	if (ctrl2 & chipcHw_REG_SOFT_RESET_VPM_GLOBAL_UNHOLD) {
		unhold = chipcHw_REG_SOFT_RESET_VPM_GLOBAL_HOLD;
	}

	if (ctrl2 & chipcHw_REG_SOFT_RESET_VPM_UNHOLD) {
		unhold |= chipcHw_REG_SOFT_RESET_VPM_HOLD;
	}

	if (ctrl2 & chipcHw_REG_SOFT_RESET_ARM_UNHOLD) {
		unhold |= chipcHw_REG_SOFT_RESET_ARM_HOLD;
	}

	if (unhold) {
		/* Make sure unhold request is effective */
		pChipcHw->SoftReset1 &= ~unhold;
	}
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief    Configures misc CHIP functionality
*
*  Configures CHIP functionality
*
*  @return   void
*
*  @note     use chipcHw_REG_MISC_CTRL_XXXXXX
*/
/****************************************************************************/
static inline void chipcHw_miscControl(uint32_t mask)
{
	reg32_write(&pChipcHw->MiscCtrl, mask);
}

static inline void chipcHw_miscControlDisable(uint32_t mask)
{
	reg32_modify_and(&pChipcHw->MiscCtrl, ~mask);
}

static inline void chipcHw_miscControlEnable(uint32_t mask)
{
	reg32_modify_or(&pChipcHw->MiscCtrl, mask);
}

/****************************************************************************/
/**
*  @brief    Set OTP options
*
*  Set OTP options
*
*  @return   void
*
*  @note     use chipcHw_REG_OTP_XXXXXX
*/
/****************************************************************************/
static inline void chipcHw_setOTPOption(uint64_t mask)
{
	uint32_t ctrl1 = (uint32_t) mask;
	uint32_t ctrl2 = (uint32_t) (mask >> 32);

	reg32_modify_or(&pChipcHw->SoftOTP1, ctrl1);
	reg32_modify_or(&pChipcHw->SoftOTP2, ctrl2);
}

/****************************************************************************/
/**
*  @brief    Get sticky bits
*
*  @return   Sticky bit options of type chipcHw_REG_STICKY_XXXXXX
*
*/
/****************************************************************************/
static inline uint32_t chipcHw_getStickyBits(void)
{
	return pChipcHw->Sticky;
}

/****************************************************************************/
/**
*  @brief    Set sticky bits
*
*  @return   void
*
*  @note     use chipcHw_REG_STICKY_XXXXXX
*/
/****************************************************************************/
static inline void chipcHw_setStickyBits(uint32_t mask)
{
	uint32_t bits = 0;

	REG_LOCAL_IRQ_SAVE;
	if (mask & chipcHw_REG_STICKY_POR_BROM) {
		bits |= chipcHw_REG_STICKY_POR_BROM;
	} else {
		uint32_t sticky;
		sticky = pChipcHw->Sticky;

		if ((mask & chipcHw_REG_STICKY_BOOT_DONE)
		    && (sticky & chipcHw_REG_STICKY_BOOT_DONE) == 0) {
			bits |= chipcHw_REG_STICKY_BOOT_DONE;
		}
		if ((mask & chipcHw_REG_STICKY_GENERAL_1)
		    && (sticky & chipcHw_REG_STICKY_GENERAL_1) == 0) {
			bits |= chipcHw_REG_STICKY_GENERAL_1;
		}
		if ((mask & chipcHw_REG_STICKY_GENERAL_2)
		    && (sticky & chipcHw_REG_STICKY_GENERAL_2) == 0) {
			bits |= chipcHw_REG_STICKY_GENERAL_2;
		}
		if ((mask & chipcHw_REG_STICKY_GENERAL_3)
		    && (sticky & chipcHw_REG_STICKY_GENERAL_3) == 0) {
			bits |= chipcHw_REG_STICKY_GENERAL_3;
		}
		if ((mask & chipcHw_REG_STICKY_GENERAL_4)
		    && (sticky & chipcHw_REG_STICKY_GENERAL_4) == 0) {
			bits |= chipcHw_REG_STICKY_GENERAL_4;
		}
		if ((mask & chipcHw_REG_STICKY_GENERAL_5)
		    && (sticky & chipcHw_REG_STICKY_GENERAL_5) == 0) {
			bits |= chipcHw_REG_STICKY_GENERAL_5;
		}
	}
	pChipcHw->Sticky = bits;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief    Clear sticky bits
*
*  @return   void
*
*  @note     use chipcHw_REG_STICKY_XXXXXX
*/
/****************************************************************************/
static inline void chipcHw_clearStickyBits(uint32_t mask)
{
	uint32_t bits = 0;

	REG_LOCAL_IRQ_SAVE;
	if (mask &
	    (chipcHw_REG_STICKY_BOOT_DONE | chipcHw_REG_STICKY_GENERAL_1 |
	     chipcHw_REG_STICKY_GENERAL_2 | chipcHw_REG_STICKY_GENERAL_3 |
	     chipcHw_REG_STICKY_GENERAL_4 | chipcHw_REG_STICKY_GENERAL_5)) {
		uint32_t sticky = pChipcHw->Sticky;

		if ((mask & chipcHw_REG_STICKY_BOOT_DONE)
		    && (sticky & chipcHw_REG_STICKY_BOOT_DONE)) {
			bits = chipcHw_REG_STICKY_BOOT_DONE;
			mask &= ~chipcHw_REG_STICKY_BOOT_DONE;
		}
		if ((mask & chipcHw_REG_STICKY_GENERAL_1)
		    && (sticky & chipcHw_REG_STICKY_GENERAL_1)) {
			bits |= chipcHw_REG_STICKY_GENERAL_1;
			mask &= ~chipcHw_REG_STICKY_GENERAL_1;
		}
		if ((mask & chipcHw_REG_STICKY_GENERAL_2)
		    && (sticky & chipcHw_REG_STICKY_GENERAL_2)) {
			bits |= chipcHw_REG_STICKY_GENERAL_2;
			mask &= ~chipcHw_REG_STICKY_GENERAL_2;
		}
		if ((mask & chipcHw_REG_STICKY_GENERAL_3)
		    && (sticky & chipcHw_REG_STICKY_GENERAL_3)) {
			bits |= chipcHw_REG_STICKY_GENERAL_3;
			mask &= ~chipcHw_REG_STICKY_GENERAL_3;
		}
		if ((mask & chipcHw_REG_STICKY_GENERAL_4)
		    && (sticky & chipcHw_REG_STICKY_GENERAL_4)) {
			bits |= chipcHw_REG_STICKY_GENERAL_4;
			mask &= ~chipcHw_REG_STICKY_GENERAL_4;
		}
		if ((mask & chipcHw_REG_STICKY_GENERAL_5)
		    && (sticky & chipcHw_REG_STICKY_GENERAL_5)) {
			bits |= chipcHw_REG_STICKY_GENERAL_5;
			mask &= ~chipcHw_REG_STICKY_GENERAL_5;
		}
	}
	pChipcHw->Sticky = bits | mask;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief    Get software strap value
*
*  Retrieves software strap value
*
*  @return   Software strap value
*
*/
/****************************************************************************/
static inline uint32_t chipcHw_getSoftStraps(void)
{
	return pChipcHw->SoftStraps;
}

/****************************************************************************/
/**
*  @brief    Set software override strap options
*
*  set software override strap options
*
*  @return   nothing
*
*/
/****************************************************************************/
static inline void chipcHw_setSoftStraps(uint32_t strapOptions)
{
	reg32_write(&pChipcHw->SoftStraps, strapOptions);
}

/****************************************************************************/
/**
*  @brief   Get Pin Strap Options
*
*  This function returns the raw boot strap options
*
*  @return  strap options
*
*/
/****************************************************************************/
static inline uint32_t chipcHw_getPinStraps(void)
{
	return pChipcHw->PinStraps;
}

/****************************************************************************/
/**
*  @brief   Get Valid Strap Options
*
*  This function returns the valid raw boot strap options
*
*  @return  strap options
*
*/
/****************************************************************************/
static inline uint32_t chipcHw_getValidStraps(void)
{
	uint32_t softStraps;

	/*
	 ** Always return the SoftStraps - bootROM calls chipcHw_initValidStraps
	 ** which copies HW straps to soft straps if there is no override
	 */
	softStraps = chipcHw_getSoftStraps();

	return softStraps;
}

/****************************************************************************/
/**
*  @brief    Initialize valid pin strap options
*
*  Retrieves valid pin strap options by copying HW strap options to soft register
*  (if chipcHw_STRAPS_SOFT_OVERRIDE not set)
*
*  @return   nothing
*
*/
/****************************************************************************/
static inline void chipcHw_initValidStraps(void)
{
	uint32_t softStraps;

	REG_LOCAL_IRQ_SAVE;
	softStraps = chipcHw_getSoftStraps();

	if ((softStraps & chipcHw_STRAPS_SOFT_OVERRIDE) == 0) {
		/* Copy HW straps to software straps */
		chipcHw_setSoftStraps(chipcHw_getPinStraps());
	}
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Get boot device
*
*  This function returns the device type used in booting the system
*
*  @return  Boot device of type chipcHw_BOOT_DEVICE
*
*/
/****************************************************************************/
static inline chipcHw_BOOT_DEVICE_e chipcHw_getBootDevice(void)
{
	return chipcHw_getValidStraps() & chipcHw_STRAPS_BOOT_DEVICE_MASK;
}

/****************************************************************************/
/**
*  @brief   Get boot mode
*
*  This function returns the way the system was booted
*
*  @return  Boot mode of type chipcHw_BOOT_MODE
*
*/
/****************************************************************************/
static inline chipcHw_BOOT_MODE_e chipcHw_getBootMode(void)
{
	return chipcHw_getValidStraps() & chipcHw_STRAPS_BOOT_MODE_MASK;
}

/****************************************************************************/
/**
*  @brief   Get NAND flash page size
*
*  This function returns the NAND device page size
*
*  @return  Boot NAND device page size
*
*/
/****************************************************************************/
static inline chipcHw_NAND_PAGESIZE_e chipcHw_getNandPageSize(void)
{
	return chipcHw_getValidStraps() & chipcHw_STRAPS_NAND_PAGESIZE_MASK;
}

/****************************************************************************/
/**
*  @brief   Get NAND flash address cycle configuration
*
*  This function returns the NAND flash address cycle configuration
*
*  @return  0 = Do not extra address cycle, 1 = Add extra cycle
*
*/
/****************************************************************************/
static inline int chipcHw_getNandExtraCycle(void)
{
	if (chipcHw_getValidStraps() & chipcHw_STRAPS_NAND_EXTRA_CYCLE) {
		return 1;
	} else {
		return 0;
	}
}

/****************************************************************************/
/**
*  @brief   Activates PIF interface
*
*  This function activates PIF interface by taking control of LCD pins
*
*  @note
*       When activated, LCD pins will be defined as follows for PIF operation
*
*       CLD[17:0]  = pif_data[17:0]
*       CLD[23:18] = pif_address[5:0]
*       CLPOWER    = pif_wr_str
*       CLCP       = pif_rd_str
*       CLAC       = pif_hat1
*       CLFP       = pif_hrdy1
*       CLLP       = pif_hat2
*       GPIO[42]   = pif_hrdy2
*
*       In PIF mode, "pif_hrdy2" overrides other shared function for GPIO[42] pin
*
*/
/****************************************************************************/
static inline void chipcHw_activatePifInterface(void)
{
	reg32_write(&pChipcHw->LcdPifMode, chipcHw_REG_PIF_PIN_ENABLE);
}

/****************************************************************************/
/**
*  @brief   Activates LCD interface
*
*  This function activates LCD interface
*
*  @note
*       When activated, LCD pins will be defined as follows
*
*       CLD[17:0]  = LCD data
*       CLD[23:18] = LCD data
*       CLPOWER    = LCD power
*       CLCP       =
*       CLAC       = LCD ack
*       CLFP       =
*       CLLP       =
*/
/****************************************************************************/
static inline void chipcHw_activateLcdInterface(void)
{
	reg32_write(&pChipcHw->LcdPifMode, chipcHw_REG_LCD_PIN_ENABLE);
}

/****************************************************************************/
/**
*  @brief   Deactivates PIF/LCD interface
*
*  This function deactivates PIF/LCD interface
*
*  @note
*       When deactivated LCD pins will be in rti-stated
*
*/
/****************************************************************************/
static inline void chipcHw_deactivatePifLcdInterface(void)
{
	reg32_write(&pChipcHw->LcdPifMode, 0);
}

/****************************************************************************/
/**
*  @brief   Select GE2
*
*  This function select GE2 as the graphic engine
*
*/
/****************************************************************************/
static inline void chipcHw_selectGE2(void)
{
	reg32_modify_and(&pChipcHw->MiscCtrl, ~chipcHw_REG_MISC_CTRL_GE_SEL);
}

/****************************************************************************/
/**
*  @brief   Select GE3
*
*  This function select GE3 as the graphic engine
*
*/
/****************************************************************************/
static inline void chipcHw_selectGE3(void)
{
	reg32_modify_or(&pChipcHw->MiscCtrl, chipcHw_REG_MISC_CTRL_GE_SEL);
}

/****************************************************************************/
/**
*  @brief   Get to know the configuration of GPIO pin
*
*/
/****************************************************************************/
static inline chipcHw_GPIO_FUNCTION_e chipcHw_getGpioPinFunction(int pin)
{
	return (*((uint32_t *) chipcHw_REG_GPIO_MUX(pin)) &
		(chipcHw_REG_GPIO_MUX_MASK <<
		 chipcHw_REG_GPIO_MUX_POSITION(pin))) >>
	    chipcHw_REG_GPIO_MUX_POSITION(pin);
}

/****************************************************************************/
/**
*  @brief   Configure GPIO pin function
*
*/
/****************************************************************************/
static inline void chipcHw_setGpioPinFunction(int pin,
					      chipcHw_GPIO_FUNCTION_e func)
{
	REG_LOCAL_IRQ_SAVE;
	*((uint32_t *) chipcHw_REG_GPIO_MUX(pin)) &=
	    ~(chipcHw_REG_GPIO_MUX_MASK << chipcHw_REG_GPIO_MUX_POSITION(pin));
	*((uint32_t *) chipcHw_REG_GPIO_MUX(pin)) |=
	    func << chipcHw_REG_GPIO_MUX_POSITION(pin);
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Set Pin slew rate
*
*  This function sets the slew of individual pin
*
*/
/****************************************************************************/
static inline void chipcHw_setPinSlewRate(uint32_t pin,
					  chipcHw_PIN_SLEW_RATE_e slewRate)
{
	REG_LOCAL_IRQ_SAVE;
	*((uint32_t *) chipcHw_REG_SLEW_RATE(pin)) &=
	    ~(chipcHw_REG_SLEW_RATE_MASK <<
	      chipcHw_REG_SLEW_RATE_POSITION(pin));
	*((uint32_t *) chipcHw_REG_SLEW_RATE(pin)) |=
	    (uint32_t) slewRate << chipcHw_REG_SLEW_RATE_POSITION(pin);
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Set Pin output drive current
*
*  This function sets output drive current of individual pin
*
*  Note: Avoid the use of the word 'current' since linux headers define this
*        to be the current task.
*/
/****************************************************************************/
static inline void chipcHw_setPinOutputCurrent(uint32_t pin,
					       chipcHw_PIN_CURRENT_STRENGTH_e
					       curr)
{
	REG_LOCAL_IRQ_SAVE;
	*((uint32_t *) chipcHw_REG_CURRENT(pin)) &=
	    ~(chipcHw_REG_CURRENT_MASK << chipcHw_REG_CURRENT_POSITION(pin));
	*((uint32_t *) chipcHw_REG_CURRENT(pin)) |=
	    (uint32_t) curr << chipcHw_REG_CURRENT_POSITION(pin);
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Set Pin pullup register
*
*  This function sets pullup register of individual pin
*
*/
/****************************************************************************/
static inline void chipcHw_setPinPullup(uint32_t pin, chipcHw_PIN_PULL_e pullup)
{
	REG_LOCAL_IRQ_SAVE;
	*((uint32_t *) chipcHw_REG_PULLUP(pin)) &=
	    ~(chipcHw_REG_PULLUP_MASK << chipcHw_REG_PULLUP_POSITION(pin));
	*((uint32_t *) chipcHw_REG_PULLUP(pin)) |=
	    (uint32_t) pullup << chipcHw_REG_PULLUP_POSITION(pin);
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Set Pin input type
*
*  This function sets input type of individual pin
*
*/
/****************************************************************************/
static inline void chipcHw_setPinInputType(uint32_t pin,
					   chipcHw_PIN_INPUTTYPE_e inputType)
{
	REG_LOCAL_IRQ_SAVE;
	*((uint32_t *) chipcHw_REG_INPUTTYPE(pin)) &=
	    ~(chipcHw_REG_INPUTTYPE_MASK <<
	      chipcHw_REG_INPUTTYPE_POSITION(pin));
	*((uint32_t *) chipcHw_REG_INPUTTYPE(pin)) |=
	    (uint32_t) inputType << chipcHw_REG_INPUTTYPE_POSITION(pin);
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Power up the USB PHY
*
*  This function powers up the USB PHY
*
*/
/****************************************************************************/
static inline void chipcHw_powerUpUsbPhy(void)
{
	reg32_modify_and(&pChipcHw->MiscCtrl,
			 chipcHw_REG_MISC_CTRL_USB_POWERON);
}

/****************************************************************************/
/**
*  @brief   Power down the USB PHY
*
*  This function powers down the USB PHY
*
*/
/****************************************************************************/
static inline void chipcHw_powerDownUsbPhy(void)
{
	reg32_modify_or(&pChipcHw->MiscCtrl,
			chipcHw_REG_MISC_CTRL_USB_POWEROFF);
}

/****************************************************************************/
/**
*  @brief   Set the 2nd USB as host
*
*  This function sets the 2nd USB as host
*
*/
/****************************************************************************/
static inline void chipcHw_setUsbHost(void)
{
	reg32_modify_or(&pChipcHw->MiscCtrl,
			chipcHw_REG_MISC_CTRL_USB_MODE_HOST);
}

/****************************************************************************/
/**
*  @brief   Set the 2nd USB as device
*
*  This function sets the 2nd USB as device
*
*/
/****************************************************************************/
static inline void chipcHw_setUsbDevice(void)
{
	reg32_modify_and(&pChipcHw->MiscCtrl,
			 chipcHw_REG_MISC_CTRL_USB_MODE_DEVICE);
}

/****************************************************************************/
/**
*  @brief   Lower layer funtion to enable/disable a clock of a certain device
*
*  This function enables/disables a core clock
*
*/
/****************************************************************************/
static inline void chipcHw_setClock(chipcHw_CLOCK_e clock,
				    chipcHw_OPTYPE_e type, int mode)
{
	volatile uint32_t *pPLLReg = (uint32_t *) 0x0;
	volatile uint32_t *pClockCtrl = (uint32_t *) 0x0;

	switch (clock) {
	case chipcHw_CLOCK_DDR:
		pPLLReg = &pChipcHw->DDRClock;
		break;
	case chipcHw_CLOCK_ARM:
		pPLLReg = &pChipcHw->ARMClock;
		break;
	case chipcHw_CLOCK_ESW:
		pPLLReg = &pChipcHw->ESWClock;
		break;
	case chipcHw_CLOCK_VPM:
		pPLLReg = &pChipcHw->VPMClock;
		break;
	case chipcHw_CLOCK_ESW125:
		pPLLReg = &pChipcHw->ESW125Clock;
		break;
	case chipcHw_CLOCK_UART:
		pPLLReg = &pChipcHw->UARTClock;
		break;
	case chipcHw_CLOCK_SDIO0:
		pPLLReg = &pChipcHw->SDIO0Clock;
		break;
	case chipcHw_CLOCK_SDIO1:
		pPLLReg = &pChipcHw->SDIO1Clock;
		break;
	case chipcHw_CLOCK_SPI:
		pPLLReg = &pChipcHw->SPIClock;
		break;
	case chipcHw_CLOCK_ETM:
		pPLLReg = &pChipcHw->ETMClock;
		break;
	case chipcHw_CLOCK_USB:
		pPLLReg = &pChipcHw->USBClock;
		if (type == chipcHw_OPTYPE_OUTPUT) {
			if (mode) {
				reg32_modify_and(pPLLReg,
						 ~chipcHw_REG_PLL_CLOCK_POWER_DOWN);
			} else {
				reg32_modify_or(pPLLReg,
						chipcHw_REG_PLL_CLOCK_POWER_DOWN);
			}
		}
		break;
	case chipcHw_CLOCK_LCD:
		pPLLReg = &pChipcHw->LCDClock;
		if (type == chipcHw_OPTYPE_OUTPUT) {
			if (mode) {
				reg32_modify_and(pPLLReg,
						 ~chipcHw_REG_PLL_CLOCK_POWER_DOWN);
			} else {
				reg32_modify_or(pPLLReg,
						chipcHw_REG_PLL_CLOCK_POWER_DOWN);
			}
		}
		break;
	case chipcHw_CLOCK_APM:
		pPLLReg = &pChipcHw->APMClock;
		if (type == chipcHw_OPTYPE_OUTPUT) {
			if (mode) {
				reg32_modify_and(pPLLReg,
						 ~chipcHw_REG_PLL_CLOCK_POWER_DOWN);
			} else {
				reg32_modify_or(pPLLReg,
						chipcHw_REG_PLL_CLOCK_POWER_DOWN);
			}
		}
		break;
	case chipcHw_CLOCK_BUS:
		pClockCtrl = &pChipcHw->ACLKClock;
		break;
	case chipcHw_CLOCK_OTP:
		pClockCtrl = &pChipcHw->OTPClock;
		break;
	case chipcHw_CLOCK_I2C:
		pClockCtrl = &pChipcHw->I2CClock;
		break;
	case chipcHw_CLOCK_I2S0:
		pClockCtrl = &pChipcHw->I2S0Clock;
		break;
	case chipcHw_CLOCK_RTBUS:
		pClockCtrl = &pChipcHw->RTBUSClock;
		break;
	case chipcHw_CLOCK_APM100:
		pClockCtrl = &pChipcHw->APM100Clock;
		break;
	case chipcHw_CLOCK_TSC:
		pClockCtrl = &pChipcHw->TSCClock;
		break;
	case chipcHw_CLOCK_LED:
		pClockCtrl = &pChipcHw->LEDClock;
		break;
	case chipcHw_CLOCK_I2S1:
		pClockCtrl = &pChipcHw->I2S1Clock;
		break;
	}

	if (pPLLReg) {
		switch (type) {
		case chipcHw_OPTYPE_OUTPUT:
			/* PLL clock output enable/disable */
			if (mode) {
				if (clock == chipcHw_CLOCK_DDR) {
					/* DDR clock enable is inverted */
					reg32_modify_and(pPLLReg,
							 ~chipcHw_REG_PLL_CLOCK_OUTPUT_ENABLE);
				} else {
					reg32_modify_or(pPLLReg,
							chipcHw_REG_PLL_CLOCK_OUTPUT_ENABLE);
				}
			} else {
				if (clock == chipcHw_CLOCK_DDR) {
					/* DDR clock disable is inverted */
					reg32_modify_or(pPLLReg,
							chipcHw_REG_PLL_CLOCK_OUTPUT_ENABLE);
				} else {
					reg32_modify_and(pPLLReg,
							 ~chipcHw_REG_PLL_CLOCK_OUTPUT_ENABLE);
				}
			}
			break;
		case chipcHw_OPTYPE_BYPASS:
			/* PLL clock bypass enable/disable */
			if (mode) {
				reg32_modify_or(pPLLReg,
						chipcHw_REG_PLL_CLOCK_BYPASS_SELECT);
			} else {
				reg32_modify_and(pPLLReg,
						 ~chipcHw_REG_PLL_CLOCK_BYPASS_SELECT);
			}
			break;
		}
	} else if (pClockCtrl) {
		switch (type) {
		case chipcHw_OPTYPE_OUTPUT:
			if (mode) {
				reg32_modify_or(pClockCtrl,
						chipcHw_REG_DIV_CLOCK_OUTPUT_ENABLE);
			} else {
				reg32_modify_and(pClockCtrl,
						 ~chipcHw_REG_DIV_CLOCK_OUTPUT_ENABLE);
			}
			break;
		case chipcHw_OPTYPE_BYPASS:
			if (mode) {
				reg32_modify_or(pClockCtrl,
						chipcHw_REG_DIV_CLOCK_BYPASS_SELECT);
			} else {
				reg32_modify_and(pClockCtrl,
						 ~chipcHw_REG_DIV_CLOCK_BYPASS_SELECT);
			}
			break;
		}
	}
}

/****************************************************************************/
/**
*  @brief   Disables a core clock of a certain device
*
*  This function disables a core clock
*
*  @note    no change in power consumption
*/
/****************************************************************************/
static inline void chipcHw_setClockDisable(chipcHw_CLOCK_e clock)
{

	/* Disable output of the clock */
	chipcHw_setClock(clock, chipcHw_OPTYPE_OUTPUT, 0);
}

/****************************************************************************/
/**
*  @brief   Enable a core clock of a certain device
*
*  This function enables a core clock
*
*  @note    no change in power consumption
*/
/****************************************************************************/
static inline void chipcHw_setClockEnable(chipcHw_CLOCK_e clock)
{

	/* Enable output of the clock */
	chipcHw_setClock(clock, chipcHw_OPTYPE_OUTPUT, 1);
}

/****************************************************************************/
/**
*  @brief   Enables bypass clock of a certain device
*
*  This function enables bypass clock
*
*  @note    Doesnot affect the bus interface clock
*/
/****************************************************************************/
static inline void chipcHw_bypassClockEnable(chipcHw_CLOCK_e clock)
{
	/* Enable bypass clock */
	chipcHw_setClock(clock, chipcHw_OPTYPE_BYPASS, 1);
}

/****************************************************************************/
/**
*  @brief   Disabled bypass clock of a certain device
*
*  This function disables bypass clock
*
*  @note    Doesnot affect the bus interface clock
*/
/****************************************************************************/
static inline void chipcHw_bypassClockDisable(chipcHw_CLOCK_e clock)
{
	/* Disable bypass clock */
	chipcHw_setClock(clock, chipcHw_OPTYPE_BYPASS, 0);

}

/****************************************************************************/
/**  @brief Checks if software strap is enabled
 *
 *   @return 1 : When enable
 *           0 : When disable
 */
/****************************************************************************/
static inline int chipcHw_isSoftwareStrapsEnable(void)
{
	return pChipcHw->SoftStraps & 0x00000001;
}

/****************************************************************************/
/**  @brief Enable software strap
 */
/****************************************************************************/
static inline void chipcHw_softwareStrapsEnable(void)
{
	reg32_modify_or(&pChipcHw->SoftStraps, 0x00000001);
}

/****************************************************************************/
/**  @brief Disable software strap
 */
/****************************************************************************/
static inline void chipcHw_softwareStrapsDisable(void)
{
	reg32_modify_and(&pChipcHw->SoftStraps, (~0x00000001));
}

/****************************************************************************/
/**  @brief PLL test enable
 */
/****************************************************************************/
static inline void chipcHw_pllTestEnable(void)
{
	reg32_modify_or(&pChipcHw->PLLConfig,
			chipcHw_REG_PLL_CONFIG_TEST_ENABLE);
}

/****************************************************************************/
/**  @brief PLL2 test enable
 */
/****************************************************************************/
static inline void chipcHw_pll2TestEnable(void)
{
	reg32_modify_or(&pChipcHw->PLLConfig2,
			chipcHw_REG_PLL_CONFIG_TEST_ENABLE);
}

/****************************************************************************/
/**  @brief PLL test disable
 */
/****************************************************************************/
static inline void chipcHw_pllTestDisable(void)
{
	reg32_modify_and(&pChipcHw->PLLConfig,
			 ~chipcHw_REG_PLL_CONFIG_TEST_ENABLE);
}

/****************************************************************************/
/**  @brief PLL2 test disable
 */
/****************************************************************************/
static inline void chipcHw_pll2TestDisable(void)
{
	reg32_modify_and(&pChipcHw->PLLConfig2,
			 ~chipcHw_REG_PLL_CONFIG_TEST_ENABLE);
}

/****************************************************************************/
/**  @brief Get PLL test status
 */
/****************************************************************************/
static inline int chipcHw_isPllTestEnable(void)
{
	return pChipcHw->PLLConfig & chipcHw_REG_PLL_CONFIG_TEST_ENABLE;
}

/****************************************************************************/
/**  @brief Get PLL2 test status
 */
/****************************************************************************/
static inline int chipcHw_isPll2TestEnable(void)
{
	return pChipcHw->PLLConfig2 & chipcHw_REG_PLL_CONFIG_TEST_ENABLE;
}

/****************************************************************************/
/**  @brief PLL test select
 */
/****************************************************************************/
static inline void chipcHw_pllTestSelect(uint32_t val)
{
	REG_LOCAL_IRQ_SAVE;
	pChipcHw->PLLConfig &= ~chipcHw_REG_PLL_CONFIG_TEST_SELECT_MASK;
	pChipcHw->PLLConfig |=
	    (val) << chipcHw_REG_PLL_CONFIG_TEST_SELECT_SHIFT;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**  @brief PLL2 test select
 */
/****************************************************************************/
static inline void chipcHw_pll2TestSelect(uint32_t val)
{

	REG_LOCAL_IRQ_SAVE;
	pChipcHw->PLLConfig2 &= ~chipcHw_REG_PLL_CONFIG_TEST_SELECT_MASK;
	pChipcHw->PLLConfig2 |=
	    (val) << chipcHw_REG_PLL_CONFIG_TEST_SELECT_SHIFT;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**  @brief Get PLL test selected option
 */
/****************************************************************************/
static inline uint8_t chipcHw_getPllTestSelected(void)
{
	return (uint8_t) ((pChipcHw->
			   PLLConfig & chipcHw_REG_PLL_CONFIG_TEST_SELECT_MASK)
			  >> chipcHw_REG_PLL_CONFIG_TEST_SELECT_SHIFT);
}

/****************************************************************************/
/**  @brief Get PLL2 test selected option
 */
/****************************************************************************/
static inline uint8_t chipcHw_getPll2TestSelected(void)
{
	return (uint8_t) ((pChipcHw->
			   PLLConfig2 & chipcHw_REG_PLL_CONFIG_TEST_SELECT_MASK)
			  >> chipcHw_REG_PLL_CONFIG_TEST_SELECT_SHIFT);
}

/****************************************************************************/
/**
*  @brief  Disable the PLL1
*
*/
/****************************************************************************/
static inline void chipcHw_pll1Disable(void)
{
	REG_LOCAL_IRQ_SAVE;
	pChipcHw->PLLConfig |= chipcHw_REG_PLL_CONFIG_POWER_DOWN;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief  Disable the PLL2
*
*/
/****************************************************************************/
static inline void chipcHw_pll2Disable(void)
{
	REG_LOCAL_IRQ_SAVE;
	pChipcHw->PLLConfig2 |= chipcHw_REG_PLL_CONFIG_POWER_DOWN;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Enables DDR SW phase alignment interrupt
*/
/****************************************************************************/
static inline void chipcHw_ddrPhaseAlignInterruptEnable(void)
{
	REG_LOCAL_IRQ_SAVE;
	pChipcHw->Spare1 |= chipcHw_REG_SPARE1_DDR_PHASE_INTR_ENABLE;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Disables DDR SW phase alignment interrupt
*/
/****************************************************************************/
static inline void chipcHw_ddrPhaseAlignInterruptDisable(void)
{
	REG_LOCAL_IRQ_SAVE;
	pChipcHw->Spare1 &= ~chipcHw_REG_SPARE1_DDR_PHASE_INTR_ENABLE;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Set VPM SW phase alignment interrupt mode
*
*  This function sets VPM phase alignment interrupt
*/
/****************************************************************************/
static inline void
chipcHw_vpmPhaseAlignInterruptMode(chipcHw_VPM_HW_PHASE_INTR_e mode)
{
	REG_LOCAL_IRQ_SAVE;
	if (mode == chipcHw_VPM_HW_PHASE_INTR_DISABLE) {
		pChipcHw->Spare1 &= ~chipcHw_REG_SPARE1_VPM_PHASE_INTR_ENABLE;
	} else {
		pChipcHw->Spare1 |= chipcHw_REG_SPARE1_VPM_PHASE_INTR_ENABLE;
	}
	pChipcHw->VPMPhaseCtrl2 =
	    (pChipcHw->
	     VPMPhaseCtrl2 & ~(chipcHw_REG_VPM_INTR_SELECT_MASK <<
			       chipcHw_REG_VPM_INTR_SELECT_SHIFT)) | mode;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Enable DDR phase alignment in software
*
*/
/****************************************************************************/
static inline void chipcHw_ddrSwPhaseAlignEnable(void)
{
	REG_LOCAL_IRQ_SAVE;
	pChipcHw->DDRPhaseCtrl1 |= chipcHw_REG_DDR_SW_PHASE_CTRL_ENABLE;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Disable DDR phase alignment in software
*
*/
/****************************************************************************/
static inline void chipcHw_ddrSwPhaseAlignDisable(void)
{
	REG_LOCAL_IRQ_SAVE;
	pChipcHw->DDRPhaseCtrl1 &= ~chipcHw_REG_DDR_SW_PHASE_CTRL_ENABLE;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Enable DDR phase alignment in hardware
*
*/
/****************************************************************************/
static inline void chipcHw_ddrHwPhaseAlignEnable(void)
{
	REG_LOCAL_IRQ_SAVE;
	pChipcHw->DDRPhaseCtrl1 |= chipcHw_REG_DDR_HW_PHASE_CTRL_ENABLE;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Disable DDR phase alignment in hardware
*
*/
/****************************************************************************/
static inline void chipcHw_ddrHwPhaseAlignDisable(void)
{
	REG_LOCAL_IRQ_SAVE;
	pChipcHw->DDRPhaseCtrl1 &= ~chipcHw_REG_DDR_HW_PHASE_CTRL_ENABLE;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Enable VPM phase alignment in software
*
*/
/****************************************************************************/
static inline void chipcHw_vpmSwPhaseAlignEnable(void)
{
	REG_LOCAL_IRQ_SAVE;
	pChipcHw->VPMPhaseCtrl1 |= chipcHw_REG_VPM_SW_PHASE_CTRL_ENABLE;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Disable VPM phase alignment in software
*
*/
/****************************************************************************/
static inline void chipcHw_vpmSwPhaseAlignDisable(void)
{
	REG_LOCAL_IRQ_SAVE;
	pChipcHw->VPMPhaseCtrl1 &= ~chipcHw_REG_VPM_SW_PHASE_CTRL_ENABLE;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Enable VPM phase alignment in hardware
*
*/
/****************************************************************************/
static inline void chipcHw_vpmHwPhaseAlignEnable(void)
{
	REG_LOCAL_IRQ_SAVE;
	pChipcHw->VPMPhaseCtrl1 |= chipcHw_REG_VPM_HW_PHASE_CTRL_ENABLE;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Disable VPM phase alignment in hardware
*
*/
/****************************************************************************/
static inline void chipcHw_vpmHwPhaseAlignDisable(void)
{
	REG_LOCAL_IRQ_SAVE;
	pChipcHw->VPMPhaseCtrl1 &= ~chipcHw_REG_VPM_HW_PHASE_CTRL_ENABLE;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Set DDR phase alignment margin in hardware
*
*/
/****************************************************************************/
static inline void
chipcHw_setDdrHwPhaseAlignMargin(chipcHw_DDR_HW_PHASE_MARGIN_e margin)
{
	uint32_t ge = 0;
	uint32_t le = 0;

	switch (margin) {
	case chipcHw_DDR_HW_PHASE_MARGIN_STRICT:
		ge = 0x0F;
		le = 0x0F;
		break;
	case chipcHw_DDR_HW_PHASE_MARGIN_MEDIUM:
		ge = 0x03;
		le = 0x3F;
		break;
	case chipcHw_DDR_HW_PHASE_MARGIN_WIDE:
		ge = 0x01;
		le = 0x7F;
		break;
	}

	{
		REG_LOCAL_IRQ_SAVE;

		pChipcHw->DDRPhaseCtrl1 &=
		    ~((chipcHw_REG_DDR_PHASE_VALUE_GE_MASK <<
		       chipcHw_REG_DDR_PHASE_VALUE_GE_SHIFT)
		      || (chipcHw_REG_DDR_PHASE_VALUE_LE_MASK <<
			  chipcHw_REG_DDR_PHASE_VALUE_LE_SHIFT));

		pChipcHw->DDRPhaseCtrl1 |=
		    ((ge << chipcHw_REG_DDR_PHASE_VALUE_GE_SHIFT)
		     || (le << chipcHw_REG_DDR_PHASE_VALUE_LE_SHIFT));

		REG_LOCAL_IRQ_RESTORE;
	}
}

/****************************************************************************/
/**
*  @brief   Set VPM phase alignment margin in hardware
*
*/
/****************************************************************************/
static inline void
chipcHw_setVpmHwPhaseAlignMargin(chipcHw_VPM_HW_PHASE_MARGIN_e margin)
{
	uint32_t ge = 0;
	uint32_t le = 0;

	switch (margin) {
	case chipcHw_VPM_HW_PHASE_MARGIN_STRICT:
		ge = 0x0F;
		le = 0x0F;
		break;
	case chipcHw_VPM_HW_PHASE_MARGIN_MEDIUM:
		ge = 0x03;
		le = 0x3F;
		break;
	case chipcHw_VPM_HW_PHASE_MARGIN_WIDE:
		ge = 0x01;
		le = 0x7F;
		break;
	}

	{
		REG_LOCAL_IRQ_SAVE;

		pChipcHw->VPMPhaseCtrl1 &=
		    ~((chipcHw_REG_VPM_PHASE_VALUE_GE_MASK <<
		       chipcHw_REG_VPM_PHASE_VALUE_GE_SHIFT)
		      || (chipcHw_REG_VPM_PHASE_VALUE_LE_MASK <<
			  chipcHw_REG_VPM_PHASE_VALUE_LE_SHIFT));

		pChipcHw->VPMPhaseCtrl1 |=
		    ((ge << chipcHw_REG_VPM_PHASE_VALUE_GE_SHIFT)
		     || (le << chipcHw_REG_VPM_PHASE_VALUE_LE_SHIFT));

		REG_LOCAL_IRQ_RESTORE;
	}
}

/****************************************************************************/
/**
*  @brief   Checks DDR phase aligned status done by HW
*
*  @return  1: When aligned
*           0: When not aligned
*/
/****************************************************************************/
static inline uint32_t chipcHw_isDdrHwPhaseAligned(void)
{
	return (pChipcHw->
		PhaseAlignStatus & chipcHw_REG_DDR_PHASE_ALIGNED) ? 1 : 0;
}

/****************************************************************************/
/**
*  @brief   Checks VPM phase aligned status done by HW
*
*  @return  1: When aligned
*           0: When not aligned
*/
/****************************************************************************/
static inline uint32_t chipcHw_isVpmHwPhaseAligned(void)
{
	return (pChipcHw->
		PhaseAlignStatus & chipcHw_REG_VPM_PHASE_ALIGNED) ? 1 : 0;
}

/****************************************************************************/
/**
*  @brief   Get DDR phase aligned status done by HW
*
*/
/****************************************************************************/
static inline uint32_t chipcHw_getDdrHwPhaseAlignStatus(void)
{
	return (pChipcHw->
		PhaseAlignStatus & chipcHw_REG_DDR_PHASE_STATUS_MASK) >>
	    chipcHw_REG_DDR_PHASE_STATUS_SHIFT;
}

/****************************************************************************/
/**
*  @brief   Get VPM phase aligned status done by HW
*
*/
/****************************************************************************/
static inline uint32_t chipcHw_getVpmHwPhaseAlignStatus(void)
{
	return (pChipcHw->
		PhaseAlignStatus & chipcHw_REG_VPM_PHASE_STATUS_MASK) >>
	    chipcHw_REG_VPM_PHASE_STATUS_SHIFT;
}

/****************************************************************************/
/**
*  @brief   Get DDR phase control value
*
*/
/****************************************************************************/
static inline uint32_t chipcHw_getDdrPhaseControl(void)
{
	return (pChipcHw->
		PhaseAlignStatus & chipcHw_REG_DDR_PHASE_CTRL_MASK) >>
	    chipcHw_REG_DDR_PHASE_CTRL_SHIFT;
}

/****************************************************************************/
/**
*  @brief   Get VPM phase control value
*
*/
/****************************************************************************/
static inline uint32_t chipcHw_getVpmPhaseControl(void)
{
	return (pChipcHw->
		PhaseAlignStatus & chipcHw_REG_VPM_PHASE_CTRL_MASK) >>
	    chipcHw_REG_VPM_PHASE_CTRL_SHIFT;
}

/****************************************************************************/
/**
*  @brief   DDR phase alignment timeout count
*
*  @note    If HW fails to perform the phase alignment, it will trigger
*           a DDR phase alignment timeout interrupt.
*/
/****************************************************************************/
static inline void chipcHw_ddrHwPhaseAlignTimeout(uint32_t busCycle)
{
	REG_LOCAL_IRQ_SAVE;
	pChipcHw->DDRPhaseCtrl2 &=
	    ~(chipcHw_REG_DDR_PHASE_TIMEOUT_COUNT_MASK <<
	      chipcHw_REG_DDR_PHASE_TIMEOUT_COUNT_SHIFT);
	pChipcHw->DDRPhaseCtrl2 |=
	    (busCycle & chipcHw_REG_DDR_PHASE_TIMEOUT_COUNT_MASK) <<
	    chipcHw_REG_DDR_PHASE_TIMEOUT_COUNT_SHIFT;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   VPM phase alignment timeout count
*
*  @note    If HW fails to perform the phase alignment, it will trigger
*           a VPM phase alignment timeout interrupt.
*/
/****************************************************************************/
static inline void chipcHw_vpmHwPhaseAlignTimeout(uint32_t busCycle)
{
	REG_LOCAL_IRQ_SAVE;
	pChipcHw->VPMPhaseCtrl2 &=
	    ~(chipcHw_REG_VPM_PHASE_TIMEOUT_COUNT_MASK <<
	      chipcHw_REG_VPM_PHASE_TIMEOUT_COUNT_SHIFT);
	pChipcHw->VPMPhaseCtrl2 |=
	    (busCycle & chipcHw_REG_VPM_PHASE_TIMEOUT_COUNT_MASK) <<
	    chipcHw_REG_VPM_PHASE_TIMEOUT_COUNT_SHIFT;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Clear DDR phase alignment timeout interrupt
*
*/
/****************************************************************************/
static inline void chipcHw_ddrHwPhaseAlignTimeoutInterruptClear(void)
{
	REG_LOCAL_IRQ_SAVE;
	/* Clear timeout interrupt service bit */
	pChipcHw->DDRPhaseCtrl2 |= chipcHw_REG_DDR_INTR_SERVICED;
	pChipcHw->DDRPhaseCtrl2 &= ~chipcHw_REG_DDR_INTR_SERVICED;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   Clear VPM phase alignment timeout interrupt
*
*/
/****************************************************************************/
static inline void chipcHw_vpmHwPhaseAlignTimeoutInterruptClear(void)
{
	REG_LOCAL_IRQ_SAVE;
	/* Clear timeout interrupt service bit */
	pChipcHw->VPMPhaseCtrl2 |= chipcHw_REG_VPM_INTR_SERVICED;
	pChipcHw->VPMPhaseCtrl2 &= ~chipcHw_REG_VPM_INTR_SERVICED;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   DDR phase alignment timeout interrupt enable
*
*/
/****************************************************************************/
static inline void chipcHw_ddrHwPhaseAlignTimeoutInterruptEnable(void)
{
	REG_LOCAL_IRQ_SAVE;
	chipcHw_ddrHwPhaseAlignTimeoutInterruptClear();	/* Recommended */
	/* Enable timeout interrupt */
	pChipcHw->DDRPhaseCtrl2 |= chipcHw_REG_DDR_TIMEOUT_INTR_ENABLE;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   VPM phase alignment timeout interrupt enable
*
*/
/****************************************************************************/
static inline void chipcHw_vpmHwPhaseAlignTimeoutInterruptEnable(void)
{
	REG_LOCAL_IRQ_SAVE;
	chipcHw_vpmHwPhaseAlignTimeoutInterruptClear();	/* Recommended */
	/* Enable timeout interrupt */
	pChipcHw->VPMPhaseCtrl2 |= chipcHw_REG_VPM_TIMEOUT_INTR_ENABLE;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   DDR phase alignment timeout interrupt disable
*
*/
/****************************************************************************/
static inline void chipcHw_ddrHwPhaseAlignTimeoutInterruptDisable(void)
{
	REG_LOCAL_IRQ_SAVE;
	pChipcHw->DDRPhaseCtrl2 &= ~chipcHw_REG_DDR_TIMEOUT_INTR_ENABLE;
	REG_LOCAL_IRQ_RESTORE;
}

/****************************************************************************/
/**
*  @brief   VPM phase alignment timeout interrupt disable
*
*/
/****************************************************************************/
static inline void chipcHw_vpmHwPhaseAlignTimeoutInterruptDisable(void)
{
	REG_LOCAL_IRQ_SAVE;
	pChipcHw->VPMPhaseCtrl2 &= ~chipcHw_REG_VPM_TIMEOUT_INTR_ENABLE;
	REG_LOCAL_IRQ_RESTORE;
}

#endif /* CHIPC_INLINE_H */
