/**
 * @file HwA_elu.h
 * @author Flagchip
 * @brief esLU hardware access layer
 * @version 2.0.0
 * @date 2024-08-20
 *
 * SDK Version: 2.6.0
 *

 * @copyright Copyright (c) 2020-2024 Flagchip Semiconductors Co., Ltd.
 *
 * @details
 */
/* ********************************************************************************
 *   Revision History:
 *
 *   Version     Date          Initials      CR#          Descriptions
 *   ---------   ----------    ------------  ----------   ---------------
 *   0.1.0      2023-12-15     Flagchip084   N/A          First version for FC7300
 *   2.0.0      2024-10-12     Flagchip084   N/A          Change version and release
 ******************************************************************************** */

#ifndef _HWA_ELU_H_
#define _HWA_ELU_H_

#include "device_header.h"

#if ELU_INSTANCE_COUNT > 0U

/**
 * @defgroup HwA_lu HwA_lu
 * @ingroup module_driver_lu
 * @{
 */

/********* Local typedef ************/
/** @brief LU LG instance */
typedef enum
{
    LU_LG_0 = 0U,
    LU_LG_1,
    LU_LG_2,
    LU_LG_3
} LU_LG_Type;

/** @brief LU AOI mode */
typedef enum
{
    LU_NO_BYPASS = 0U,
    LU_LUT0_BYPASS,
    LU_LUT1_BYPASS,
    LU_LUT0_LUT1_BYPASS
} LU_LG_BypassModeType;

/** @brief LU FF mode */
typedef enum
{
    LU_BYPASS_MODE0 = 0U,
    LU_RS_MODE,
    LU_TFF_MODE,
    LU_DFF_MODE,
    LU_JKFF_MODE,
    LU_LATCH_MODE,
    LU_NORMAL0_MODE,
    LU_NORMAL1_MODE
} LU_LG_ConfigModeType;

/** @brief LU Input(n) type */
typedef enum
{
    LU_INPUT_N_A = 0U,
    LU_INPUT_N_B,
    LU_INPUT_N_C,
    LU_INPUT_N_D
} LU_LG_InputNType;

typedef enum
{
    LU_INPUT_LU = 0U,
    LU_INPUT_DU_OUTA,
    LU_INPUT_DU_OUTB,
    LU_INPUT_DU_OUTC
} LU_InputDType;

typedef enum
{
    LU_OUTPUT_LG = 0U,
    LU_OUTPUT_DU_OUTA,
    LU_OUTPUT_DU_OUTB,
    LU_OUTPUT_DU_OUTC,
} LU_OutputDType;

typedef enum
{
    LU_PRESCALER_DIV_0 = 0,
    LU_PRESCALER_DIV_2,
    LU_PRESCALER_DIV_3,
    LU_PRESCALER_DIV_8,
    LU_PRESCALER_DIV_16,
    LU_PRESCALER_DIV_32,
    LU_PRESCALER_DIV_64,
    LU_PRESCALER_DIV_128
} LU_PrescalerType;

typedef enum
{
    LU_FLEX_SAMP_EVEN_EDGES = 0,  /** 00b - Sampling on even edges.*/
    LU_FLEX_SAMP_ODD_EDGES ,    /** 01b - Sampling on odd edges.*/
    LU_FLEX_SAMP_SEND_EVEN_EDGES,  /** 10b - Sending on even edges.*/
    LU_FLEX_SAMP_SEND_ODD_EDGES    /** 11b - Sending on odd edges.*/
} LU_FlexSampType;

typedef enum
{
    LU_OPC_NONE = 0,
    LU_OPC_INCR ,        /** 0001b - INCR.*/
    LU_OPC_DECR ,        /** 0010b - DECR.*/
    LU_OPC_INCR_WRAP ,   /** 0011b - INCR_Wrap.*/
    LU_OPC_DECR_WRAP ,   /** 0100b - DECR_Wrap.*/
    LU_OPC_INCR_DECR ,   /** 0101b - INCR_DECR.*/
    LU_OPC_INCR_DECR_WRAP ,  /** 0110b - INCR_DECR_Wrap.*/
    LU_OPC_INCR_WRAP_MODE1 ,  /** 0111b - INCR_Wrap_Mode1.*/
    LU_OPC_INCR_DECR_WRAP_MODE1 ,  /** 1000b - INCR_DECR_Wrap_Mode1.*/
    LU_OPC_SHIFT_IN_LEFT ,  /** 1001b - Shift In Left.*/
    LU_OPC_SHIFT_IN_RIGHT ,  /** 1010b - Shift In Right.*/
    LU_OPC_SHIFT_OUT_LEFT ,  /** 1011b - Shift Out Left.*/
    LU_OPC_SHIFT_OUT_RIGHT ,  /** 1100b - Shift Out Right.*/
    LU_OPC_FLEX,  /** 1101b - FLEX.*/
    LU_OPC_DATA_MATCH  /** 1110b - Data Match.*/
} LU_DU_OpcType;

typedef enum
{
    INPUTAMUX_VSS = 0,
    INPUTAMUX_VDD ,
    INPUTAMUX_LG0_LUT0_OUT ,
    INPUTAMUX_LG0_LUT1_OUT ,
    INPUTAMUX_LG1_LUT0_OUT ,
    INPUTAMUX_LG1_LUT1_OUT ,
    INPUTAMUX_LG2_LUT0_OUT ,
    INPUTAMUX_LG2_LUT1_OUT ,
    INPUTAMUX_LG3_LUT0_OUT ,
    INPUTAMUX_LG3_LUT1_OUT ,
    INPUTAMUX_LU_DATA_UNIT_OUTA ,
    INPUTAMUX_LU_DATA_UNIT_OUTB ,
    INPUTAMUX_LU_DATA_UNIT_OUTC 
} LU_DU_InputMuxType;

typedef enum
{
    LU_DU_CAPTURE_NONE = 0, /**< do not use capture*/
    LU_DU_CAPTURE_POS_EDGE ,
    LU_DU_CAPTURE_NEG_EDGE ,
    LU_DU_CAPTURE_BOTH_EDGE
}LU_DU_CaptureModeType;

/********* Local inline function ************/
/**
 * @brief Configure LU LG(n) configuration
 *
 * @param pLu LU instance
 * @param eLg LG instance
 * @param u32RegValue LUT register value
 */
LOCAL_INLINE void LU_HWA_ConfigCfg(LU_Type *pLu, LU_LG_Type eLg, uint32_t u32RegValue)
{
    pLu->LG[eLg].LG_CFG = u32RegValue;
}

/**
 * @brief Configure LU LG(n) configuration
 *
 * @param pLu LU instance
 * @param eLg LG instance
 * @param u32RegValue LUT0 register value
 */
LOCAL_INLINE void LU_HWA_SetConfigCfgLut0(LU_Type *pLu, LU_LG_Type eLg, uint32_t u32RegValue)
{
    pLu->LG[eLg].LG_CFG |= LU_LG_CFG_LUT0_CTRL(u32RegValue);
}

/**
 * @brief Configure LU LG(n) configuration
 *
 * @param pLu LU instance
 * @param eLg LG instance
 * @param u32RegValue LUT1 register value
 */
LOCAL_INLINE void LU_HWA_SetConfigCfgLut1(LU_Type *pLu, LU_LG_Type eLg, uint32_t u32RegValue)
{
    pLu->LG[eLg].LG_CFG |= LU_LG_CFG_LUT1_CTRL(u32RegValue);
}

/**
 * @brief Configure LU LG(n) contrl configuration
 *
 * @param pLu LU instance
 * @param eLg LG instance
 * @param u32RegValue CTRL register value
 */
LOCAL_INLINE void LU_HWA_ConfigCtrl(LU_Type *pLu, LU_LG_Type eLg, uint32_t u32RegValue)
{
    pLu->LG[eLg].LG_CTRL = u32RegValue;
}

/**
 * @brief Configure LU LG(n) filter configuration
 *
 * @param pLu LU instance
 * @param eLg LG instance
 * @param u32RegValue FILT register value
 */
LOCAL_INLINE void LU_HWA_ConfigFilter(LU_Type *pLu, LU_LG_Type eLg, uint32_t u32RegValue)
{
    pLu->LG[eLg].LG_FILT = u32RegValue;
}

/**
 * @brief Configures the DMA selection.
 *
 * @param pLu LU instance
 * @param eLg LG instance
 */
LOCAL_INLINE void LU_HWA_ConfigDmaSel(LU_Type *pLu, LU_LG_Type eLg)
{
    pLu->LG[eLg].LG_CTRL |= (uint32_t)LU_DU_CTRL_DMASEL_MASK;
}

/**
 * @brief  Configures the Interrupt selection.
 *
 * @param pLu LU instance
 * @param eLg LG instance
 */
LOCAL_INLINE void LU_HWA_ConfigIntSel(LU_Type *pLu, LU_LG_Type eLg)
{
    pLu->LG[eLg].LG_CTRL |= (uint32_t)LU_DU_CTRL_INTSEL_MASK;
}

/**
 * @brief Configures the input selection.
 *
 * @param pLu Pointer to the LU instance.
 * @param eLg LG instance.
 * @param eInput Input selection.
 */
LOCAL_INLINE void LU_HWA_ConfigInuptSelToA(LU_Type *pLu, LU_LG_Type eLg, LU_InputDType eInput)
{
    uint32_t u32TempRegValue = pLu->LG[eLg].LG_CTRL;
    pLu->LG[eLg].LG_CTRL = ((u32TempRegValue & ~(uint32_t)LU_LG_CTRL_INPUTASEL_MASK) | LU_LG_CTRL_INPUTASEL(eInput));
}

/**
 * @brief Configures the input selection.
 *
 * @param pLu Pointer to the LU instance.
 * @param eLg LG instance.
 * @param eInput Input selection.
 */
LOCAL_INLINE void LU_HWA_ConfigInuptSelToB(LU_Type *pLu, LU_LG_Type eLg, LU_InputDType eInput)
{
    uint32_t u32TempRegValue = pLu->LG[eLg].LG_CTRL;
    pLu->LG[eLg].LG_CTRL = ((u32TempRegValue & ~(uint32_t)LU_LG_CTRL_INPUTBSEL_MASK) | LU_LG_CTRL_INPUTBSEL(eInput));
}

/**
 * @brief  Configures the input selection.
 *
 * @param pLu Pointer to the LU instance.
 * @param eLg LG instance.
 * @param eInput Input selection.
 */
LOCAL_INLINE void LU_HWA_ConfigInuptSelToC(LU_Type *pLu, LU_LG_Type eLg, LU_InputDType eInput)
{
    uint32_t u32TempRegValue = pLu->LG[eLg].LG_CTRL;
    pLu->LG[eLg].LG_CTRL = ((u32TempRegValue & ~(uint32_t)LU_LG_CTRL_INPUTCSEL_MASK) | LU_LG_CTRL_INPUTCSEL(eInput));
}

/**
 * @brief Configures the input selection.
 *
 * @param pLu Pointer to the LU instance.
 * @param eLg LG instance.
 * @param eInput Input selection.
 */
LOCAL_INLINE void LU_HWA_ConfigInuptSelToD(LU_Type *pLu, LU_LG_Type eLg, LU_InputDType eInput)
{
    uint32_t u32TempRegValue = pLu->LG[eLg].LG_CTRL;
    pLu->LG[eLg].LG_CTRL = ((u32TempRegValue & ~(uint32_t)LU_LG_CTRL_INPUTDSEL_MASK) | LU_LG_CTRL_INPUTDSEL(eInput));
}

/**
 * @brief Set LG bypass control
 *
 * @param pLu LU instance
 * @param eLg LG instance
 * @param eMode LG bypass control mode
 */
LOCAL_INLINE void LU_HWA_SetLgBypassControl(LU_Type *pLu, LU_LG_Type eLg, LU_LG_BypassModeType eMode)
{
    uint32_t u32TempRegValue = pLu->LG[eLg].LG_CTRL;
    pLu->LG[eLg].LG_CTRL = ((u32TempRegValue & ~(uint32_t)LU_LG_CTRL_BYPASS_MASK) | LU_LG_CTRL_BYPASS(eMode));
}

/**
 * @brief Set LG inputs synchronous control
 *
 * @param pLu LU instance
 * @param eLg LG instance
 * @param u32Value LG input bit,0-3 bit indicate INPUT(n)A/INPUT(n)B/INPUT(n)C/INPUT(n)D
 */
LOCAL_INLINE void LU_HWA_SetLgInputsSyncCtrl(LU_Type *pLu, LU_LG_Type eLg, uint32_t u32Value)
{
    uint32_t u32TempRegValue = pLu->LG[eLg].LG_CTRL;
    pLu->LG[eLg].LG_CTRL = ((u32TempRegValue & ~(uint32_t)LU_LG_CTRL_SYNC_MASK) | LU_LG_CTRL_SYNC(u32Value));
}

/**
 * @brief Set LG output feedback override control
 *
 * @param pLu LU instance
 * @param eLg LG instance
 * @param eInput Feedback to LG input
 */
LOCAL_INLINE void LU_HWA_SetLgFeedbackOverrideCtrl(LU_Type *pLu, LU_LG_Type eLg, LU_LG_InputNType eInput)
{
    uint32_t u32TempRegValue = pLu->LG[eLg].LG_CTRL;
    pLu->LG[eLg].LG_CTRL = ((u32TempRegValue & ~(uint32_t)LU_LG_CTRL_FB_OVRD_MASK) | LU_LG_CTRL_FB_OVRD(eInput));
}

/**
 * @brief Set LG Flip-Flop mode
 *
 * @param pLu LU instance
 * @param eLg LG instance
 * @param eMode Flip-Flop mode
 */
LOCAL_INLINE void LU_HWA_SetLgFlipFlopMode(LU_Type *pLu, LU_LG_Type eLg, LU_LG_ConfigModeType eMode)
{
    uint32_t u32TempRegValue = pLu->LG[eLg].LG_CTRL;
    pLu->LG[eLg].LG_CTRL = ((u32TempRegValue & ~(uint32_t)LU_LG_CTRL_MOD_MASK) | LU_LG_CTRL_MOD(eMode));
}

/**
 * @brief Generate enable pulse
 *
 * @param pLu LU instance
 * @param eLg LG instance
 */
LOCAL_INLINE void LU_HWA_EnableControlFlipFlopInitOutput(LU_Type *pLu, LU_LG_Type eLg)
{
    pLu->LG[eLg].LG_CTRL |= (uint32_t)LU_LG_CTRL_INIT_EN_MASK;
}

/**
 * @brief Configure the output of flip-flop as "1"
 *
 * @param pLu LU instance
 * @param eLg LG instance
 */
LOCAL_INLINE void LU_HWA_ConfigFlipFlopTo1(LU_Type *pLu, LU_LG_Type eLg)
{
    pLu->LG[eLg].LG_CTRL |= (uint32_t)LU_LG_CTRL_FF_INIT_MASK;
}

/**
 * @brief Configure the output of flip-flop as "0"
 *
 * @param pLu LU instance
 * @param eLg LG instance
 */
LOCAL_INLINE void LU_HWA_ConfigFlipFlopTo0(LU_Type *pLu, LU_LG_Type eLg)
{
    pLu->LG[eLg].LG_CTRL &= ~(uint32_t)LU_LG_CTRL_FF_INIT_MASK;
}

/**
 * @brief Input filter sample count for LUT0
 *
 * @param pLu LU instance
 * @param eLg LG instance
 * @param u32Value Sample count value
 */
LOCAL_INLINE void LU_HWA_SetLUT0InputFilterSampleCount(LU_Type *pLu, LU_LG_Type eLg, uint32_t u32Value)
{
    uint32_t u32TempRegValue = pLu->LG[eLg].LG_FILT;
    pLu->LG[eLg].LG_FILT = ((u32TempRegValue & ~(uint32_t)LU_LG_FILT_CNT0_MASK) | LU_LG_FILT_CNT0(u32Value));
}

/**
 * @brief Input filter sample period for LUT0
 *
 * @param pLu LU instance
 * @param eLg LG instance
 * @param u32Value Sample period value
 */
LOCAL_INLINE void LU_HWA_SetLUT0InputFilterSamplePeriod(LU_Type *pLu, LU_LG_Type eLg, uint32_t u32Value)
{
    uint32_t u32TempRegValue = pLu->LG[eLg].LG_FILT;
    pLu->LG[eLg].LG_FILT = ((u32TempRegValue & ~(uint32_t)LU_LG_FILT_PRE0_MASK) | LU_LG_FILT_PRE0(u32Value));
}

/**
 * @brief Input filter sample count for LUT1
 *
 * @param pLu LU instance
 * @param eLg LG instance
 * @param u32Value Sample count value
 */
LOCAL_INLINE void LU_HWA_SetLUT1InputFilterSampleCount(LU_Type *pLu, LU_LG_Type eLg, uint32_t u32Value)
{
    uint32_t u32TempRegValue = pLu->LG[eLg].LG_FILT;
    pLu->LG[eLg].LG_FILT = ((u32TempRegValue & ~(uint32_t)LU_LG_FILT_CNT1_MASK) | LU_LG_FILT_CNT1(u32Value));
}

/**
 * @brief Input filter sample period for LUT1
 *
 * @param pLu LU instance
 * @param eLg LG instance
 * @param u32Value Sample period value
 */
LOCAL_INLINE void LU_HWA_SetLUT1InputFilterSamplePeriod(LU_Type *pLu, LU_LG_Type eLg, uint32_t u32Value)
{
    uint32_t u32TempRegValue = pLu->LG[eLg].LG_FILT;
    pLu->LG[eLg].LG_FILT = ((u32TempRegValue & ~(uint32_t)LU_LG_FILT_PRE1_MASK) | LU_LG_FILT_PRE1(u32Value));
}

/**
 * @brief Input filter sample period for LUT1
 *
 * @param pLu LU instance
 * @param eLg LG instance
 * @param u32Value Sample period value
 */
LOCAL_INLINE void LU_HWA_SetControlPrescaler(LU_Type *pLu, LU_PrescalerType ePrescaler)
{
    pLu->CTRL |= LU_CTRL_PS(ePrescaler);
}

/**
 * @brief Input filter sample period for LUT1
 *
 * @param pLu LU instance
 * @param eLg LG instance
 * @param u32Value Sample period value
 */
LOCAL_INLINE void LU_HWA_SetIntStatus(LU_Type *pLu, uint32_t u32W1cFlag)
{
    pLu->INT_ST |= LU_INT_ST_LUTINTST(u32W1cFlag);
}

/**
 * @brief Input filter sample period for LUT1
 *
 * @param pLu LU instance
 * @param eLg LG instance
 * @param u32Value Sample period value
 */
LOCAL_INLINE uint32_t LU_HWA_GetIntStatus(LU_Type *pLu)
{
    return (pLu->INT_ST & LU_INT_ST_LUTINTST_MASK);
}

/**
 * @brief Input filter sample period for LUT1
 *
 * @param pLu LU instance
 * @param eLg LG instance
 * @param u32Value Sample period value
 */
LOCAL_INLINE void LU_HWA_SetConfigCfg(LU_Type *pLu, uint32_t u32RegValue)
{
    pLu->CFG = u32RegValue;
}

/**
 * @brief Input filter sample period for LUT1
 *
 * @param pLu LU instance
 */
LOCAL_INLINE void LU_HWA_EnableCofigCfgInt(LU_Type *pLu)
{
    pLu->CFG |= LU_CFG_INTEN_MASK;
}

/**
 * @brief Input filter sample period for LUT1
 *
 * @param pLu LU instance
 */
LOCAL_INLINE void LU_HWA_DisableCofigCfgInt(LU_Type *pLu)
{
    pLu->CFG &= ~LU_CFG_INTEN_MASK;
}

/**
 * @brief Input filter sample period for LUT1
 *
 * @param pLu LU instance
 */
LOCAL_INLINE void LU_HWA_SoftReset(LU_Type *pLu)
{
    pLu->SW_RESET = 0xFC50AF50;
}

/**
 * @brief Sets the configuration of the Data Unit Control Register
 *
 * @param pLu Pointer to the LU_Type instance
 * @param u32RegValue The value to be written to the DU_CFG register
 */
LOCAL_INLINE void LU_HWA_SetConfigDuCfg(LU_Type *pLu, uint32_t u32RegValue)
{
    pLu->DU_CFG = u32RegValue;
}

/**
 * @brief Sets the configuration of the Data Unit Control Register
 *
 * @param pLu Pointer to the LU_Type instance
 * @param u32RegValue The value to be written to the DU_CTRL register
 */
LOCAL_INLINE void LU_HWA_SetConfigDuCTRL(LU_Type *pLu, uint32_t u32RegValue)
{
    pLu->DU_CTRL = u32RegValue;
}

/**
 * @brief Enables the FlexMode Data Compare feature
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_EnableDuCtrlComp(LU_Type *pLu)
{
    pLu->DU_CTRL |= LU_DU_CTRL_COMP_MASK;
}

/**
 * @brief Disables the FlexMode Data Compare feature
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_DisableDuCtrlComp(LU_Type *pLu)
{
    pLu->DU_CTRL &= ~LU_DU_CTRL_COMP_MASK;
}

/**
 * @brief Enables the Continuous Mode
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_EnableDuCfgCone(LU_Type *pLu)
{
    pLu->DU_CFG |= LU_DU_CTRL_CONEN_MASK;
}

/**
 * @brief Disables the Continuous Mode
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_DisableDuCfgCone(LU_Type *pLu)
{
    pLu->DU_CFG &= ~LU_DU_CTRL_CONEN_MASK;
}

/**
 * @brief Enables the Capture Mode
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_ConfigDuCtrlCapture(LU_Type *pLu, LU_DU_CaptureModeType eCaptureCfg)
{
    pLu->DU_CTRL |= LU_DU_CTRL_CAPMODE(eCaptureCfg);
}

/**
 * @brief Enables the DMA Selection feature
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_EnableDuCtrlDma(LU_Type *pLu)
{
    pLu->DU_CTRL |= LU_DU_CTRL_DMASEL_MASK;
}

/**
 * @brief Disables the DMA Selection feature
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_DisableDuCtrlDma(LU_Type *pLu)
{
    pLu->DU_CTRL &= ~LU_DU_CTRL_DMASEL_MASK;
}

/**
 * @brief Enables the Interrupt Selection feature
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_EnableDuCtrlInt(LU_Type *pLu)
{
    pLu->DU_CTRL |= LU_DU_CTRL_INTSEL_MASK;
}

/**
 * @brief Disables the Interrupt Selection feature
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_DisableDuCtrlInt(LU_Type *pLu)
{
    pLu->DU_CTRL &= ~LU_DU_CTRL_INTSEL_MASK;
}

/**
 * @brief Sets the OUTC Initial Polarity to low valid
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_SetDuCfgOutLow(LU_Type *pLu)
{
    pLu->DU_CFG |= LU_DU_CTRL_OUTCINIT_MASK;
}

/**
 * @brief Sets the OUTC Initial Polarity to high valid
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_SetDuCfgOutCHigh(LU_Type *pLu)
{
    pLu->DU_CFG &= ~LU_DU_CTRL_OUTCINIT_MASK;
}

/**
 * @brief Enables the Initial Sample feature
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_EnableDuCfgInitSamp(LU_Type *pLu)
{
    pLu->DU_CFG |= LU_DU_CTRL_SAMPINIT_MASK;
}

/**
 * @brief Disables the Initial Sample feature
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_DisableDuCfgInitSamp(LU_Type *pLu)
{
    pLu->DU_CFG &= ~LU_DU_CTRL_SAMPINIT_MASK;
}

/**
 * @brief Enables the Initial Shift Out feature
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_EnableDuCfgInitShift(LU_Type *pLu)
{
    pLu->DU_CFG |= LU_DU_CTRL_SHIFTOUTINIT_MASK;
}

/**
 * @brief Disables the Initial Shift Out feature
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_DisableDuCfgInitShift(LU_Type *pLu)
{
    pLu->DU_CFG &= ~LU_DU_CTRL_SHIFTOUTINIT_MASK;
}

/**
 * @brief Sets the Compare Type to Equal compare
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_SetDuCfgCompEqual(LU_Type *pLu)
{
    pLu->DU_CFG |= LU_DU_CTRL_COMPTYPE_MASK;
}

/**
 * @brief Sets the Compare Type to Toggle compare
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_SetDuCfgCompToggle(LU_Type *pLu)
{
    pLu->DU_CFG &= ~LU_DU_CTRL_COMPTYPE_MASK;
}

/**
 * @brief Sets the Compare Size
 *
 * @param pLu Pointer to the LU_Type instance
 * @param u32Value The size to be set (1-32 bits)
 */
LOCAL_INLINE void LU_HWA_SetDuCfgCompSize(LU_Type *pLu, uint32_t u32Value)
{
    pLu->DU_CFG |= LU_DU_CTRL_COMPSIZE(u32Value);
}

/**
 * @brief Sets the Input Trigger Mode
 *
 * @param pLu Pointer to the LU_Type instance
 * @param u32Value The trigger mode value to be set
 */
LOCAL_INLINE void LU_HWA_SetDuCfgInTrigerMode(LU_Type *pLu, uint32_t u32Value)
{
    pLu->DU_CFG |= LU_DU_CTRL_INPUTTRIG(u32Value);
}

/**
 * @brief Sets the Multi Pin Compare Type to All pin meet
 *
 * @param pLu Pointer to the LU_Type instance
 * @param u32Value The value to be set for the COMPTOGTYPE field
 */
LOCAL_INLINE void LU_HWA_SetDuCfgCompPinAll(LU_Type *pLu, uint32_t u32Value)
{
    (void)u32Value;
    pLu->DU_CFG |= LU_DU_CTRL_COMPTYPE_MASK;
}

/**
 * @brief Sets the Multi Pin Compare Type to Any pin meet
 *
 * @param pLu Pointer to the LU_Type instance
 * @param u32Value The value to be set for the COMPTOGTYPE field
 */
LOCAL_INLINE void LU_HWA_SetDuCfgCompPinAny(LU_Type *pLu, uint32_t u32Value)
{
    (void)u32Value;
    pLu->DU_CFG &= ~LU_DU_CTRL_COMPTYPE_MASK;
}

/**
 * @brief Enables Both Edge Mode
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_EnableDuCfgEdge(LU_Type *pLu)
{
    pLu->DU_CFG |= LU_DU_CTRL_EDGEMODE_MASK;
}

/**
 * @brief Disables Both Edge Mode
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_DisableDuCfgEdge(LU_Type *pLu)
{
    pLu->DU_CFG &= ~LU_DU_CTRL_EDGEMODE_MASK;
}

/**
 * @brief Sets the Sample Control in Flex Mode
 *
 * @param pLu Pointer to the LU_Type instance
 * @param u32Value The value to be set for the FLEX_SAMP field
 */
LOCAL_INLINE void LU_HWA_SetDuCfgFlexSamp(LU_Type *pLu, LU_FlexSampType eFlexSampValue)
{
    pLu->DU_CFG |= LU_DU_CTRL_FLEX_SAMP(eFlexSampValue);
}

/**
 * @brief Sets the Clock Initial Polarity to high
 *
 * @param pLu Pointer to the LU_Type instance
 * @param u32Value The value to be set for the CLKINIT field
 */
LOCAL_INLINE void LU_HWA_SetDuCfgClkHigh(LU_Type *pLu, uint32_t u32Value)
{
    pLu->DU_CFG |= LU_DU_CTRL_CLKINIT(u32Value);
}

/**
 * @brief Sets the Clock Initial Polarity to low
 *
 * @param pLu Pointer to the LU_Type instance
 * @param u32Value The value to be set for the CLKINIT field
 */
LOCAL_INLINE void LU_HWA_SetDuCfgClkLow(LU_Type *pLu, uint32_t u32Value)
{
    pLu->DU_CFG &= ~LU_DU_CTRL_CLKINIT(u32Value);
}

/**
 * @brief Sets the LU Data Unit Operation Code
 *
 * @param pLu Pointer to the LU_Type instance
 * @param u32Value The value to be set for the OPC field
 */
LOCAL_INLINE void LU_HWA_SetDuCfgOpc(LU_Type *pLu, LU_DU_OpcType eOpcValue)
{
    // Note: There seems to be an error in the original code, it should use LU_DU_CTRL_OPC_MASK instead of LU_DU_CTRL_FLEX_SAMP(u32Value)
    pLu->DU_CFG |= LU_DU_CTRL_OPC(eOpcValue);
}

/**
 * @brief Sets the INPUTAMUX selection
 *
 * @param pLu Pointer to the LU_Type instance
 * @param sel The selection for INPUTAMUX
 */
LOCAL_INLINE void LU_HWA_SetInputAmux(LU_Type *pLu, LU_DU_InputMuxType eInputMuxSel)
{
    pLu->DU_INPUT_SEL |= LU_DU_INPUT_SEL_INPUTAMUX(eInputMuxSel);
}

/**
 * @brief Sets the INPUTBMUX selection (same as INPUTAMUX)
 *
 * @param pLu Pointer to the LU_Type instance
 * @param sel The selection for INPUTBMUX
 */
LOCAL_INLINE void LU_HWA_SetInputBmux(LU_Type *pLu, LU_DU_InputMuxType eInputMuxSel)
{
    pLu->DU_INPUT_SEL |= LU_DU_INPUT_SEL_INPUTBMUX(eInputMuxSel);
}

/**
 * @brief Sets the INPUTCMUX selection (same as INPUTAMUX)
 *
 * @param pLu Pointer to the LU_Type instance
 * @param sel The selection for INPUTCMUX
 */
LOCAL_INLINE void LU_HWA_SetInputCmux(LU_Type *pLu, LU_DU_InputMuxType eInputMuxSel)
{
    pLu->DU_INPUT_SEL |= LU_DU_INPUT_SEL_INPUTCMUX(eInputMuxSel);
}

/**
 * @brief Clears the buffer
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_ClearBuffer(LU_Type *pLu)
{
    pLu->DU_CFG |= LU_DU_CFG_BUFFERCLR_MASK;
}

/**
 * @brief Disables buffer clearing
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_DisableBufferClear(LU_Type *pLu)
{
    pLu->DU_CFG &= ~LU_DU_CFG_BUFFERCLR_MASK;
}

/**
 * @brief Enables Interrupt Match
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_EnableInterruptMatch(LU_Type *pLu)
{
    pLu->DU_CFG |= LU_DU_CFG_INTMATCH_MASK;
}

/**
 * @brief Disables Interrupt Match
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_DisableInterruptMatch(LU_Type *pLu)
{
    pLu->DU_CFG &= ~LU_DU_CFG_INTMATCH_MASK;
}

/**
 * @brief Enables Interrupt Underflow
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_EnableInterruptUnderflow(LU_Type *pLu)
{
    pLu->DU_CFG |= LU_DU_CFG_INTUNDERFLOW_MASK;
}

/**
 * @brief Disables Interrupt Underflow
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_DisableInterruptUnderflow(LU_Type *pLu)
{
    pLu->DU_CFG &= ~LU_DU_CFG_INTUNDERFLOW_MASK;
}

/**
 * @brief Enables Interrupt Overflow
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_EnableInterruptOverflow(LU_Type *pLu)
{
    pLu->DU_CFG |= LU_DU_CFG_INTOVERFLOW_MASK;
}

/**
 * @brief Disables Interrupt Overflow
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_DisableInterruptOverflow(LU_Type *pLu)
{
    pLu->DU_CFG &= ~LU_DU_CFG_INTOVERFLOW_MASK;
}

/**
 * @brief Enables DMA Match
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_EnableDmaMatch(LU_Type *pLu)
{
    pLu->DU_CFG |= LU_DU_CFG_DMAMATCH_MASK;
}

/**
 * @brief Disables DMA Match
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_DisableDmaMatch(LU_Type *pLu)
{
    pLu->DU_CFG &= ~LU_DU_CFG_DMAMATCH_MASK;
}

/**
 * @brief Enables DMA Underflow
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_EnableDmaUnderflow(LU_Type *pLu)
{
    pLu->DU_CFG |= LU_DU_CFG_DMAUNDERFLOW_MASK;
}

/**
 * @brief Disables DMA Underflow
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_DisableDmaUnderflow(LU_Type *pLu)
{
    pLu->DU_CFG &= ~LU_DU_CFG_DMAUNDERFLOW_MASK;
}

/**
 * @brief Enables DMA Overflow
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_EnableDmaOverflow(LU_Type *pLu)
{
    pLu->DU_CFG |= LU_DU_CFG_DMAOVERFLOW_MASK;
}

/**
 * @brief Disables DMA Overflow
 *
 * @param pLu Pointer to the LU_Type instance
 */
LOCAL_INLINE void LU_HWA_DisableDmaOverflow(LU_Type *pLu)
{
    pLu->DU_CFG &= ~LU_DU_CFG_DMAOVERFLOW_MASK;
}

/**
 * @brief Sets the Start Counter Config
 *
 * @param pLu Pointer to the LU_Type instance
 * @param config The configuration value for the start counter
 */
LOCAL_INLINE void LU_HWA_SetStartCounterConfig(LU_Type *pLu, uint8_t config)
{
    pLu->DU_CFG = (pLu->DU_CFG & ~LU_DU_CFG_STARTCFG_MASK) | LU_DU_CFG_STARTCFG(config);
}

/**
 * @brief Sets the Transmit Bit Number
 *
 * @param pLu Pointer to the LU_Type instance
 * @param bitNumber The bit number to be transmitted
 */
LOCAL_INLINE void LU_HWA_SetTransmitBitNumber(LU_Type *pLu, uint8_t bitNumber)
{
    pLu->DU_CFG = (pLu->DU_CFG & ~LU_DU_CFG_BITCFG_MASK) | LU_DU_CFG_BITCFG(bitNumber);
}

/**
 * @brief Sets the value of the Data Unit Data0 Register
 *
 * @param pLu Pointer to the LU_Type instance
 * @param data The value to be written to the DATA0 register
 */
LOCAL_INLINE void LU_HWA_SetLuDuData0(LU_Type *pLu, uint32_t data)
{
    pLu->DU_DATA0 = data;
}

/**
 * @brief Gets the value of the Data Unit Data0 Register
 *
 * @param pLu Pointer to the LU_Type instance
 * @return The value of the DATA0 register
 */
LOCAL_INLINE uint32_t LU_HWA_GetLuDuData0(LU_Type *pLu)
{
    return pLu->DU_DATA0;
}

/**
 * @brief Sets the value of the Data Unit Data1 Register
 *
 * @param pLu Pointer to the LU_Type instance
 * @param data The value to be written to the DATA1 register
 */
LOCAL_INLINE void LU_HWA_SetLuDuData1(LU_Type *pLu, uint32_t data)
{
    pLu->DU_DATA1 = data;
}

/**
 * @brief Gets the value of the Data Unit Data1 Register
 *
 * @param pLu Pointer to the LU_Type instance
 * @return The value of the DATA1 register
 */
LOCAL_INLINE uint32_t LU_HWA_GetLuDuData1(LU_Type *pLu)
{
    return pLu->DU_DATA1;
}

/**
 * @brief Sets the value of the Data Unit Data2 Register
 *
 * @param pLu Pointer to the LU_Type instance
 * @param data The value to be written to the DATA2 register
 */
LOCAL_INLINE void LU_HWA_SetLuDuData2(LU_Type *pLu, uint32_t data)
{
    pLu->DU_DATA2 = data;
}

/**
 * @brief Gets the value of the Data Unit Data2 Register
 *
 * @param pLu Pointer to the LU_Type instance
 * @return The value of the DATA2 register
 */
LOCAL_INLINE uint32_t LU_HWA_GetLuDuData2(LU_Type *pLu)
{
    return pLu->DU_DATA2;
}

/**
 * @brief Gets the value of the Data Unit Data3 Register
 *
 * @param pLu Pointer to the LU_Type instance
 * @return The value of the DATA3 register
 */
LOCAL_INLINE uint32_t LU_HWA_GetLuDuData3(LU_Type *pLu)
{
    return pLu->DU_DATA3;
}

/**
 * @brief Gets the value of the Data Unit Data4 Register
 *
 * @param pLu Pointer to the LU_Type instance
 * @return The value of the DATA4 register
 */
LOCAL_INLINE uint32_t LU_HWA_GetLuDuData4(LU_Type *pLu)
{
    return pLu->DU_DATA4;
}

/**
 * @brief Gets the value of the Data Unit Data5 Register
 *
 * @param pLu Pointer to the LU_Type instance
 * @return The value of the DATA5 register
 */
LOCAL_INLINE uint32_t LU_HWA_GetLuDuData5(LU_Type *pLu)
{
    return pLu->DU_DATA5;
}

/**
 * @brief Gets the value of the Data Unit Data6 Register
 *
 * @param pLu Pointer to the LU_Type instance
 * @return The value of the DATA6 register
 */
LOCAL_INLINE uint32_t LU_HWA_GetLuDuData6(LU_Type *pLu)
{
    return pLu->DU_DATA6;
}

/**
 * @brief Sets the value of the Data Unit Data7 Register
 *
 * @param pLu Pointer to the LU_Type instance
 * @param data The value to be written to the DATA7 register
 */
LOCAL_INLINE void LU_HWA_SetLuDuData7(LU_Type *pLu, uint32_t data)
{
    pLu->DU_DATA7 = data;
}

/**
 * @brief Gets the value of the Data Unit Data7 Register
 *
 * @param pLu Pointer to the LU_Type instance
 * @return The value of the DATA7 register
 */
LOCAL_INLINE uint32_t LU_HWA_GetLuDuData7(LU_Type *pLu)
{
    return pLu->DU_DATA7;
}

/** @}*/


#endif /* #if ELU_INSTANCE_COUNT > 0U */

#endif /* #ifndef _HWA_LU_H_ */