/*!
* @file     Adc.h
*
* @version  1.0.0
*
* @brief    AUTOSAR Dio Driver header file
*
* @attention
*
* Project Name      : AUTOSAR MCAL
*
* Platform          : Arm
*
* Autosar Standard  : Classic Platform 4.4.0
*
* Compiled Version  : G32A10xx_MCAL_1_0_0_01-Otc-25
*
* Copyright (C) 2026 Geehy Semiconductor
*
* You may not use this file except in compliance with the
* GEEHY COPYRIGHT NOTICE (Geehy Semiconductor Software License Agreement).
*
* The program is only for reference, which is distributed in the hope
* that it will be usefull and instructional for customers to develop
* their software. Unless required by applicable law or agreed to in
* writing, the program is distributed on an "AS IS" BASIS, WITHOUT
* ANY WARRANTY OR CONDITIONS OF ANY KIND, either express or implied.
* See the Geehy Semiconductor Software License Agreement for the governing permissions
* and limitations under the License.
*/

/*
* MISRA-C:2012 compliance checks
*
*      Adc_h_MISRA_REF1
*          Breaks the required M3CM Rule-1.1 of MISRA 2012 guidelines,
*          The program shall contain no violations of the standard C syntax and constraints, and shall not exceed the implementation's translation limits
*/

#ifndef ADC_H
#define ADC_H


#ifdef __cplusplus
extern "C"{
#endif

#include "Adc_Cfg.h"

/** @addtogroup G32A10xx_StdPeriphDriver
  @{
*/

/** @addtogroup ADC_Driver
  @{
*/

/** @defgroup ADC_Macros
  @{
*/
/*******************************************************************************
                    VENDOR ID & AUTOSAR VERSION INFO
*******************************************************************************/
/** Vendor ID (vendorId) of the dedicated implementation of this module according to the AUTOSAR vendor list. */
#define ADC_H_VENDOR_ID                                0x00C1U
/* Module ID of this module, as defined in the BSW Module List. */
#define ADC_H_MODULE_ID                                0x0065U
/** Major version number of AUTOSAR release on which the appropriate implementation is based on. */
#define ADC_H_AR_RELEASE_MAJOR_VERSION                 0x04U
/** Minor version number of AUTOSAR release on which the appropriate implementation is based on. */
#define ADC_H_AR_RELEASE_MINOR_VERSION                 0x04U
/** Revision version number of AUTOSAR release on which the appropriate implementation is based on. */
#define ADC_H_AR_RELEASE_REVISION_VERSION              0x00U
/** Major version number of the vendor specific implementation of the module. The numbering is vendor specific. */
#define ADC_H_SW_MAJOR_VERSION                         0x01U
/** Minor version number of the vendor specific implementation of the module. The numbering is vendor specific. */
#define ADC_H_SW_MINOR_VERSION                         0x00U
/** Patch level version number of the vendor specific implementation of the module. The numbering is vendor specific. */
#define ADC_H_SW_PATCH_VERSION                         0x00U

/*******************************************************************************
                                ERROR CODES
*******************************************************************************/

/** API service called without module initialization */
#define ADC_E_UNINIT                ((uint8)0x0AU)

/** API service called when the module is busy running an operation */
#define ADC_E_BUSY                  ((uint8)0x0BU)

/** API service called while no conversion is running */
#define ADC_E_IDLE                  ((uint8)0x0CU)

/** API service Adc_Init called while ADC is already initialized */
#define ADC_E_ALREADY_INITIALIZED   ((uint8)0x0DU)

/** API service called with incorrect configuration */
#define ADC_E_PARAM_CONFIG          ((uint8)0x0EU)

/** API service called with invalid pointer */
#define ADC_E_PARAM_POINTER         ((uint8)0x14U)

/** API service called with invalid group ID */
#define ADC_E_PARAM_GROUP           ((uint8)0x15U)

/** API service called with wrong conversion mode */
#define ADC_E_WRONG_CONV_MODE       ((uint8)0x16U)

/** API service called with wrong trigger source */
#define ADC_E_WRONG_TRIGG_SRC       ((uint8)0x17U)

/**
* API services Adc_EnableGroupNotification or Adc_DisableGroupNotification
* called on a group whose configuration set has no notification available.
*/
#define ADC_E_NOTIF_CAPABILITY      ((uint8)0x18U)

/**
* API services Adc_StartGroupConversion or Adc_EnableHardwareTrigger
* called on a group whose result buffer pointer was not initialized.
*/
#define ADC_E_BUFFER_UNINIT         ((uint8)0x19U)

/** One or more ADC group/channel not in IDLE state */
#define ADC_E_NOT_DISENGAGED        ((uint8)0x1AU)

/** Unsupported power state request */
#define ADC_E_POWER_STATE_NOT_SUPPORTED     ((uint8)0x1BU)

/** Requested power state can not be reached directly */
#define ADC_E_TRANSITION_NOT_POSSIBLE       ((uint8)0x1CU)

/** ADC not prepared for target power state */
#define ADC_E_PERIPHERAL_NOT_PREPARED       ((uint8)0x1DU)

/*******************************************************************************
                            API Service ID List
*******************************************************************************/
/** Service ID for Adc_Init */
#define SID_ADC_INIT                                ((uint8)0x00U)

/** Service ID for Adc_DeInit */
#define SID_ADC_DEINIT                              ((uint8)0x01U)

/** Service ID for Adc_StartGroupConversion */
#define SID_ADC_START_GROUP_CONVERSION              ((uint8)0x02U)

/** Service ID for Adc_StopGroupConversion */
#define SID_ADC_STOP_GROUP_CONVERSION               ((uint8)0x03U)

/** Service ID for Adc_ReadGroup */
#define SID_ADC_READ_GROUP                          ((uint8)0x04U)

/** Service ID for Adc_EnableHardwareTrigger */
#define SID_ADC_ENABLE_HARDWARE_TRIGGER             ((uint8)0x05U)

/** Service ID for Adc_DisableHardwareTrigger */
#define SID_ADC_DISABLE_HARDWARE_TRIGGER            ((uint8)0x06U)

/** Service ID for Adc_EnableGroupNotification */
#define SID_ADC_ENABLE_GROUP_NOTIFICATION           ((uint8)0x07U)

/** Service ID for Adc_DisableGroupNotification */
#define SID_ADC_DISABLE_GROUP_NOTIFICATION          ((uint8)0x08U)

/** Service ID for Adc_GetGroupStatus */
#define SID_ADC_GET_GROUP_STATUS                    ((uint8)0x09U)

/** Service ID for Adc_GetVersionInfo */
#define SID_ADC_GET_VERSION_INFO                    ((uint8)0x0AU)

/** Service ID for Adc_GetStreamLastPointer */
#define SID_ADC_GET_STREAM_LAST_POINTER             ((uint8)0x0BU)

/** Service ID for Adc_SetupResultBuffer */
#define SID_ADC_SETUP_RESULT_BUFFER                 ((uint8)0x0CU)

/*******************************************************************************
                             MACRO DEFINITION
*******************************************************************************/
#define ADC_STATUS_REG ((volatile Adc_statusBitType *)0x40012400)
    
/**@} end of group ADC_Macros */
/*******************************************************************************
                            ENUM DEFINITION
*******************************************************************************/
/** @defgroup ADC_Enumerations
  @{
*/

/**
 * @brief    ADC clock mode
 */
typedef enum
{
    ADC_CLOCK_MODE_ASYNCLK    = ((uint32)0x00000000u), /* ADC Asynchronous clock mode */
    ADC_CLOCK_MODE_SYNCLKDIV2 = ((uint32)0x40000000u), /* Synchronous clock mode divided by 2 */
    /*** @warning Adc_h_MISRA_REF1 [C] Enumeration constants must have values representable as 'int's. */
    ADC_CLOCK_MODE_SYNCLKDIV4 = ((uint32)0x80000000u)  /* Synchronous clock mode divided by 4 */
} Adc_ClkModeType;



/**
 * @brief    ADC data resolution
 */
typedef enum
{
    ADC_RESOLUTION_12B = ((uint8_t)0x00), /* ADC Resolution is 12 bits */
    ADC_RESOLUTION_10B = ((uint8_t)0x01), /* ADC Resolution is 10 bits */
    ADC_RESOLUTION_8B  = ((uint8_t)0x02), /* ADC Resolution is 8 bits */
    ADC_RESOLUTION_6B  = ((uint8_t)0x03)  /* ADC Resolution is 6 bits */
} Adc_ResolutionType;


typedef enum
{
    ADC_TRIGG_SRC_SW = 0x00, /* Group is triggered by a software API call */
    ADC_TRIGG_SRC_HW = 0x01  /* Group is triggered by a hardware event */
} Adc_TriggerSourceType;



typedef enum
{
    ADC_HW_TRIG_INVALID = 0x0,
    ADC_HW_TRIG_RISING_EDGE = 0x1,  /* React on the rising edge of the hardware trigger signal (only if supported by the ADC hardware). */
    ADC_HW_TRIG_FALLING_EDGE = 0x2, /* React on the falling edge of the hardware trigger signal (only if supported by the ADC hardware). */
    ADC_HW_TRIG_BOTH_EDGES = 0x3 /* React on both edges of the hardware trigger signal (only if supported by the ADC hardware). */
} Adc_HwTriggerSignalType;



typedef enum
{
    ADC_EXT_TRIG_CONV_TRG0 = ((uint8_t)0x00), /*!< ADC External Trigger Conversion timer1 TRG0 */
    ADC_EXT_TRIG_CONV_TRG1 = ((uint8_t)0x01), /*!< ADC External Trigger Conversion timer1 CC4 */
    ADC_EXT_TRIG_CONV_TRG2 = ((uint8_t)0x02), /*!< ADC External Trigger Conversion timer2 TRGO */
    ADC_EXT_TRIG_CONV_TRG3 = ((uint8_t)0x03), /*!< ADC External Trigger Conversion timer3 TRG0 */
    ADC_EXT_TRIG_CONV_TRG4 = ((uint8_t)0x04), /*!< ADC External Trigger Conversion timer15 TRG0 */
    ADC_EXT_TRIG_INVALID   = ((uint8_t)0x05)
} Adc_TriggerEventType;



typedef enum
{
    ADC_CONV_MODE_ONESHOT = 0x00, /*  */
    ADC_CONV_MODE_CONTINUOUS = 0x01  /*  */
} Adc_GroupConvModeType;



typedef enum
{
    ADC_ALIGN_LEFT = 0x00, /*  */
    ADC_ALIGN_RIGHT = 0x01  /*  */
} Adc_ResultAlignmentType;


typedef enum
{
    ADC_SAMPLE_TIME_1_5   = ((uint8_t)0x00),  /* 1.5 ADC clock cycles */
    ADC_SAMPLE_TIME_7_5   = ((uint8_t)0x01),  /* 7.5 ADC clock cycles */
    ADC_SAMPLE_TIME_13_5  = ((uint8_t)0x02),  /* 13.5 ADC clock cycles */
    ADC_SAMPLE_TIME_28_5  = ((uint8_t)0x03),  /* 28.5 ADC clock cycles */
    ADC_SAMPLE_TIME_41_5  = ((uint8_t)0x04),  /* 41.5 ADC clock cycles */
    ADC_SAMPLE_TIME_55_5  = ((uint8_t)0x05),  /* 55.5 ADC clock cycles */
    ADC_SAMPLE_TIME_71_5  = ((uint8_t)0x06),  /* 71.5 ADC clock cycles */
    ADC_SAMPLE_TIME_239_5 = ((uint8_t)0x07)   /* 239.5 ADC clock cycles */
} Adc_SamplingTimeType;


typedef enum
{
    ADC_CHANNEL_0    = ((uint32_t)0x00000001),  /* ADC Channel 0 */
    ADC_CHANNEL_1    = ((uint32_t)0x00000002),  /* ADC Channel 1 */
    ADC_CHANNEL_2    = ((uint32_t)0x00000004),  /* ADC Channel 2 */
    ADC_CHANNEL_3    = ((uint32_t)0x00000008),  /* ADC Channel 3 */
    ADC_CHANNEL_4    = ((uint32_t)0x00000010),  /* ADC Channel 4 */
    ADC_CHANNEL_5    = ((uint32_t)0x00000020),  /* ADC Channel 5 */
    ADC_CHANNEL_6    = ((uint32_t)0x00000040),  /* ADC Channel 6 */
    ADC_CHANNEL_7    = ((uint32_t)0x00000080),  /* ADC Channel 7 */
    ADC_CHANNEL_8    = ((uint32_t)0x00000100),  /* ADC Channel 8 */
    ADC_CHANNEL_9    = ((uint32_t)0x00000200),  /* ADC Channel 9 */
    ADC_CHANNEL_10   = ((uint32_t)0x00000400),  /* ADC Channel 10 */
    ADC_CHANNEL_11   = ((uint32_t)0x00000800),  /* ADC Channel 11 */
    ADC_CHANNEL_12   = ((uint32_t)0x00001000),  /* ADC Channel 12 */
    ADC_CHANNEL_13   = ((uint32_t)0x00002000),  /* ADC Channel 13 */
    ADC_CHANNEL_14   = ((uint32_t)0x00004000),  /* ADC Channel 14 */
    ADC_CHANNEL_15   = ((uint32_t)0x00008000),  /* ADC Channel 15 */
    ADC_CHANNEL_16   = ((uint32_t)0x00010000),  /* ADC Channel 16 */
    ADC_CHANNEL_17   = ((uint32_t)0x00020000),  /* ADC Channel 17 */
    ADC_CHANNEL_18   = ((uint32_t)0x00040000)   /* ADC Channel 18 */
} Adc_ChannelType;


/**
* @brief      The access Mode of Adc group-AUTOSAR standard type.
*/
typedef enum
{
    ADC_ACCESS_MODE_SINGLE = 0U, //!< Single access mode 
    ADC_ACCESS_MODE_STREAMING = 1U //!< Streaming access mode
} Adc_GroupAccessModeType;


/**
* @brief      The streaming buffer mode of Adc group-AUTOSAR standard type
*/
typedef enum
{
    ADC_STREAM_BUFFER_LINEAR = 0U, //!< Linear streaming
    ADC_STREAM_BUFFER_CIRCULAR = 1U //!< Circular streaming
} Adc_StreamBufferModeType;


/**
* @brief      Selected ADC Transmission Mode
*/
typedef enum
{
    ADC_TRANS_MODE_INTERRUPT = 0U, //!< interrupt trans mode
    ADC_TRANS_MODE_DMA = 1U        //!< dma trans mode
} Adc_TransModeSelectType;


#if (ADC_HARDWARE_TRIG_API == STD_ON)
typedef enum
{
    ADC_TIME1_ID = 1U,
    ADC_TIME2_ID = 2U,
    ADC_TIME3_ID = 3U,
    ADC_TIME4_ID = 4U
} Adc_TimerHwIdType;

/**
 * @brief   ADC flag
 */
typedef enum
{
    ADC_TMR_RESET_TRGO  = 0x0,
    ADC_TMR_ENABLE_TRGO = 0x1,
    ADC_TMR_UPDATE_TRGO = 0x2,
    ADC_TMR_COMPARISON_TRGO = 0x3,
    ADC_TMR_OC1REF_TRGO = 0x4,
    ADC_TMR_OC2REF_TRGO = 0x5,
    ADC_TMR_OC3REF_TRGO = 0x6,
    ADC_TMR_OC4REF_TRGO = 0x7
} Adc_TRGOSignalType;
#endif

/**
* @brief      The status of ADC Unit 
*/   
typedef enum
{
    ADC_UNIT_STATE_UNINIT = 0U,
    ADC_UNIT_STATE_BUSY = 1U,
    ADC_UNIT_STATE_IDLE = 2U
} Adc_UnitStateType;

/**
* @brief      The status of ADC group-AUTOSAR standard type.
*/
typedef enum
{
    ADC_IDLE = 0U, //!< IDLE state
    ADC_BUSY = 1U, //!< BUSY state
    ADC_COMPLETED = 2U, //!< COMPLETED state
    ADC_STREAM_COMPLETED = 3U //!< STREAM_COMPLETED state
} Adc_StatusType;


/**
* @brief      ADC group notification is enabled/disabled.
*/
typedef enum
{
    ADC_GROUP_NOTIFICATION_DISABLED = 0U, //!< Notification of a group is disabled
    ADC_GROUP_NOTIFICATION_ENABLED = 1U //!< Notification of a group is enabled
} Adc_GroupNotificationType;

/**
 * @brief   ADC interrupts definition
 */
typedef enum
{
    ADC_INT_ADCRDY  = ((uint8)0x01), //!< ADC ready interrupt
    ADC_INT_EOSMP   = ((uint8)0x02), //!< End of sampling interrupt
    ADC_INT_EOC     = ((uint8)0x04), //!< End of conversion interrupt
    ADC_INT_EOSEQ   = ((uint8)0x08), //!< End of sequence interrupt
    ADC_INT_OVR     = ((uint8)0x10), //!< ADC overrun interrupt
    ADC_INT_AWD     = ((uint8)0x80)  //!< Analog watchdog interrupt
} Adc_IntType;

/**
 * @brief   ADC Interrupt flag
 */
typedef enum
{
    ADC_INT_FLAG_ADCRDY = ((uint8)0x01), //!< ADC ready interrupt flag
    ADC_INT_FLAG_EOSMP  = ((uint8)0x02), //!< End of sampling interrupt flag
    ADC_INT_FLAG_EOC    = ((uint8)0x04), //!< End of conversion interrupt flag
    ADC_INT_FLAG_EOSEQ  = ((uint8)0x08), //!< End of sequence interrupt flag
    ADC_INT_FLAG_OVR    = ((uint8)0x10), //!< ADC overrun interrupt flag
    ADC_INT_FLAG_AWD    = ((uint8)0x80)  //!< Analog watchdog interrupt flag
} Adc_IntFlgType;

/**@} end of group ADC_Enumerations */
/*******************************************************************************
                            STRUCT DEFINITION
*******************************************************************************/
/** @defgroup ADC_Typedef
  @{
*/

/** The adc group type */
typedef uint16 Adc_GroupType;
typedef uint16 Adc_StreamNumSampleType;
typedef uint16 Adc_ValueGroupType;
typedef void (*Adc_NotifyFunctionType)(void);

/**@} end of group ADC_Typedef */

/** @defgroup ADC_Structure
  @{
*/
typedef struct{
    uint32_t ADCRDYFLG  : 1;
    uint32_t EOSMPFLG   : 1;
    uint32_t EOCFLG     : 1;
    uint32_t EOSEQFLG   : 1;
    uint32_t OVREFLG    : 1;
    uint32_t RESERVED1  : 2;
    uint32_t AWDFLG     : 1;
    uint32_t RESERVED2  : 24;
} Adc_statusBitType;


typedef struct {
    Adc_GroupAccessModeType accessMode;
    Adc_StreamBufferModeType streamMode;
    Adc_StreamNumSampleType streamNumSamples;
} Adc_GroupAccessConfigType;

typedef struct {
    uint8 channel;
    
    Adc_SamplingTimeType sampleTime;
    Adc_ChannelType adcHwChannel;
} Adc_ChannelConfigType;


typedef struct {
    uint8 groupID;
#if (STD_ON == ADC_PRIORITY_IMPLEMENTATION)
    uint8 adcGroupPriority; /* you xian ji */
#endif
    boolean enableNonPreemptable;
    
    Adc_GroupAccessConfigType accessModeCfg;
    
    uint8 channelCount;
    Adc_ChannelConfigType channelCfg[ADC_MAX_CHANNELS];
   
    Adc_TriggerSourceType selTrigger;
    Adc_HwTriggerSignalType selHwTriggerSignal;
    Adc_TriggerEventType triggerEvent;      /* External Trigger Event Select */
    
#if (ADC_HARDWARE_TRIG_API == STD_ON)
    Adc_TimerHwIdType hwUnitId;
    Adc_TRGOSignalType TrgoSel;
#endif

    uint8 enableBack;    /* qian/hou */
    Adc_GroupConvModeType converMode;         
    
    uint16** adcGroupResultBuffer;
    const Adc_NotifyFunctionType adcGroupNotification;
    Adc_ResultAlignmentType dataAlignment;        /* zuo/you */
    
#if (STD_ON == ADC_LIMIT_VALUE_DETECTION_ENABLE)
    boolean AnalogWatchdog;
    uint16 lowThreshold;
    uint16 highThreshold;
#endif

} Adc_GroupConfigType;


/**
 * @brief    The structure data setted by Configurator is used for initializing the ADC Driver and ADC HW Unit(s).
 */
typedef struct {
    uint8 adcSelect;
    
    Adc_ClkModeType adcClockSel; /* adc clock */
    Adc_ResolutionType dataResolution;  /* 12-bit/10-bit/8-bit */

    Adc_TransModeSelectType selectTranMode;
    
    uint8 groupMaxNum;
    const Adc_GroupConfigType *addGroupCfg;
} Adc_ConfigType;


/**
* @brief   ADC group status record type
*/
typedef struct {
    /** adc group status */
    volatile Adc_StatusType groupStatus;
    /** ADC interrupt user callback status */
    volatile Adc_GroupNotificationType notificationStatus;
} Adc_GroupStatusRecordType;


/**
* @brief   ADC group queue config type
*/
typedef struct {
    /** adc group queue */
    volatile Adc_GroupType groupQueue[20];
    /** adc group priority queue */
    volatile uint16 priorityQueue[20];
} Adc_GroupQueueConfigType;


/**
* @brief    Structure of ADC hardware unit status.
*/
typedef struct
{
    uint8 queueCount;
    Adc_GroupQueueConfigType groupPriority;
} Adc_UnitStatusRecordType;

/**@} end of group ADC_Structure */
/*******************************************************************************
                             CONSTANT DEFINITION
*******************************************************************************/
/** @defgroup ADC_Variable
  @{
*/
extern CONST(Adc_GroupConfigType, PORT_CONST) g_adcGroupConfig[ADC_MAXIMUN_GROUPS_SET];
#if (STD_ON == ADC_DMA_TRANSFER_MODE)
extern P2VAR(Adc_ValueGroupType, ADC_VAR, ADC_APPL_DATA) Adc_DmaBuf_Pointer[];
#endif
extern CONST(Adc_ConfigType, PORT_CONST) g_adcConfig;

#define ADC_START_SEC_VAR_INIT_UNSPECIFIED
#include "Adc_MemMap.h"

extern volatile P2CONST(Adc_ConfigType, ADC_VAR, ADC_APPL_CONST) g_adcConfigPtr;
extern P2CONST(Adc_GroupConfigType, ADC_VAR, ADC_APPL_CONST) g_adcGroupPtr;
extern Adc_GroupType g_adcActiveGroup;

/**@} end of group ADC_Variable */

#define ADC_STOP_SEC_VAR_INIT_UNSPECIFIED
#include "Adc_MemMap.h"

#define ADC_START_SEC_VAR_NO_INIT_UNSPECIFIED
#include "Adc_MemMap.h"

/** @defgroup ADC_Variable
  @{
*/

extern Adc_UnitStatusRecordType g_adcHwPrioQueStatus;
extern VAR(Adc_GroupStatusRecordType, ADC_VAR) g_adcGroupStatus[ADC_MAXIMUN_GROUPS_SET];

/**@} end of group ADC_Variable */

#define ADC_STOP_SEC_VAR_NO_INIT_UNSPECIFIED
#include "Adc_MemMap.h"

#define ADC_START_SEC_VAR_INIT_8
#include "Adc_MemMap.h"

/** @defgroup ADC_Variable
  @{
*/

extern uint16 g_adcCurrentChannel;
extern uint8 g_adcIrqQueueNum;
extern uint8 g_adcIrqQueueNumLinear;

/**@} end of group ADC_Variable */

#define ADC_STOP_SEC_VAR_INIT_8
#include "Adc_MemMap.h"

/*******************************************************************************
                            FUNCTION DECLARATION
*******************************************************************************/
#define ADC_START_SEC_CODE
#include "Adc_MemMap.h"

/** @defgroup ADC_Fuctions
  @{
*/
void Adc_RemoveQueueMem(Adc_GroupType Group);
void Adc_Init(P2CONST(Adc_ConfigType, AUTOMATIC, ADC_APPL_CONST) ConfigPtr);

void Adc_DeInit(void);

#if (STD_ON == ADC_START_STOP_GROUP_API)
void Adc_StartGroupConversion(Adc_GroupType Group);
void Adc_StopGroupConversion(Adc_GroupType Group);
#endif

Adc_StreamNumSampleType Adc_GetStreamLastPointer(Adc_GroupType Group, 
                                                 Adc_ValueGroupType** PtrToSamplePtr);
Std_ReturnType Adc_SetupResultBuffer(Adc_GroupType Group,Adc_ValueGroupType * DataBufferPtr);

#if (ADC_HARDWARE_TRIG_API == STD_ON)
void Adc_EnableHardwareTrigger(Adc_GroupType Group);
void Adc_DisableHardwareTrigger(Adc_GroupType Group);
#endif

#if (STD_ON == ADC_GROUP_NOTIFICATION_API)
void Adc_EnableGroupNotification(Adc_GroupType Group);
void Adc_DisableGroupNotification(Adc_GroupType Group);
#endif

#if (ADC_VERSINFO_API == STD_ON)
FUNC(void, MCU_CODE) Adc_GetVersionInfo(P2VAR(Std_VersionInfoType, AUTOMATIC, ADC_APPL_DATA) VersionInfo);
#endif

#if (STD_ON == ADC_DMA_TRANSFER_MODE)
FUNC(void, GPT_CODE) Adc_DmaChannel1CompletionNotificaiton(void);
#endif

/**@} end of group ADC_Fuctions */

#define ADC_STOP_SEC_CODE
#include "Adc_MemMap.h"

#ifdef __cplusplus
}
#endif

#endif /* ADC_TYPES_H */

/**@} end of group ADC_Driver */
/**@} end of group G32A10xx_StdPeriphDriver */
