adc/v2/adc.h

Go to the documentation of this file.

/*
 * Copyright (C) 2024 Texas Instruments Incorporated
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 *   Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the
 *   distribution.
 *
 *   Neither the name of Texas Instruments Incorporated nor the names of
 *   its contributors may be used to endorse or promote products derived
 *   from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef ADC_V2_H_
#define ADC_V2_H_
 
//*****************************************************************************
//
// If building with a C++ compiler, make all of the definitions in this header
// have a C binding.
//
//*****************************************************************************
#ifdef __cplusplus
extern "C"
{
#endif
 
//*****************************************************************************
//
//
//*****************************************************************************
#include <stdint.h>
#include <stdbool.h>
#include <drivers/hw_include/hw_types.h>
#include <drivers/hw_include/cslr_soc.h>
#include <kernel/dpl/DebugP.h>
#include <drivers/hw_include/cslr_adc.h>
//*****************************************************************************
//
//
//*****************************************************************************
#define ADC_ADCSOCxCTL_STEP (CSL_ADC_ADCSOC1CTL - CSL_ADC_ADCSOC0CTL)
#define ADC_ADCINTSELxNy_STEP (CSL_ADC_ADCINTSEL3N4 - CSL_ADC_ADCINTSEL1N2)
#define ADC_ADCPPBx_STEP (CSL_ADC_ADCPPB2CONFIG - CSL_ADC_ADCPPB1CONFIG)
#define ADC_ADCPPBTRIP_MASK ((uint32_t)CSL_ADC_ADCPPB1TRIPHI_LIMITHI_MASK \
                               | (uint32_t)CSL_ADC_ADCPPB1TRIPHI_HSIGN_MASK)
#define ADC_RESULT_ADCPPBxRESULT_STEP (CSL_ADC_RESULT_ADCPPB2RESULT -\
                                                CSL_ADC_RESULT_ADCPPB1RESULT)
#define ADC_RESULT_ADCRESULTx_STEP (CSL_ADC_RESULT_ADCRESULT1 - \
                                        CSL_ADC_RESULT_ADCRESULT0)
//*****************************************************************************
//
// Define to mask out the bits in the REPxCTL register that aren't associated
// with repeater configuration.
//
//*****************************************************************************
#define ADC_REPCTL_MASK             (CSL_ADC_REP1CTL_MODE_MASK               |\
                                     CSL_ADC_REP1CTL_TRIGGER_MASK            |\
                                     CSL_ADC_REP1CTL_SYNCINSEL_MASK)
 
 
#define ADC_ADCPPBxCONFIG2_STEP (CSL_ADC_ADCPPB2CONFIG2 - CSL_ADC_ADCPPB1CONFIG2)
#define ADC_REPxCTL_STEP        (CSL_ADC_REP2CTL - CSL_ADC_REP1CTL)
#define ADC_REPxN_STEP          (CSL_ADC_REP2N - CSL_ADC_REP1N)
#define ADC_REPxPHASE_STEP      (CSL_ADC_REP2PHASE - CSL_ADC_REP1PHASE)
#define ADC_REPxSPREAD_STEP     (CSL_ADC_REP2SPREAD - CSL_ADC_REP1SPREAD)
 
 
#define ADC_PPBxTRIPHI_STEP     (CSL_ADC_ADCPPB1TRIPHI - CSL_ADC_ADCPPB1TRIPHI)
#define ADC_PPBxTRIPLO_STEP     (CSL_ADC_ADCPPB2TRIPLO - CSL_ADC_ADCPPB1TRIPLO)
#define ADC_ADCPPBxLIMIT_STEP   (CSL_ADC_ADCPPB2LIMIT - CSL_ADC_ADCPPB1LIMIT)
#define ADC_ADCPPBxPCOUNT_STEP   (CSL_ADC_ADCPPBP2PCOUNT - CSL_ADC_ADCPPBP1PCOUNT)
#define ADC_ADCPPBxCONFIG2_STEP   (CSL_ADC_ADCPPB2CONFIG2 - CSL_ADC_ADCPPB1CONFIG2)
#define ADC_ADCPPBxPSUM_STEP   (CSL_ADC_ADCPPB2PSUM - CSL_ADC_ADCPPB1PSUM)
#define ADC_ADCPPBxPMAX_STEP   (CSL_ADC_ADCPPB2PMAX - CSL_ADC_ADCPPB1PMAX)
#define ADC_ADCPPBxPMAXI_STEP   (CSL_ADC_ADCPPB2PMAXI - CSL_ADC_ADCPPB1PMAXI)
#define ADC_ADCPPBxPMIN_STEP   (CSL_ADC_ADCPPB2PMIN - CSL_ADC_ADCPPB1PMIN)
#define ADC_ADCPPBxPMINI_STEP   (CSL_ADC_ADCPPB2PMINI - CSL_ADC_ADCPPB1PMINI)
#define ADC_ADCPPBxTRIPLO2_STEP   (CSL_ADC_ADCPPB2TRIPLO2 - CSL_ADC_ADCPPB1TRIPLO2)
 
//*****************************************************************************
//
// Define to mask out the bits in the REPSTATUS register that aren't
// associated with trigger repeater block status.
//
//*****************************************************************************
#define ADC_REPSTATUS_MASK      (CSL_ADC_REP1CTL_MODULEBUSY_MASK             |\
                                 CSL_ADC_REP1CTL_PHASEOVF_MASK               |\
                                 CSL_ADC_REP1CTL_TRIGGEROVF_MASK)
 
//*****************************************************************************
//
// Define to mask out the bits in the CHECKSTATUS register that aren't
// associated with safety checker result status.
//
//*****************************************************************************
#define ADC_SAFECHECK_STATUS_MASK   (CSL_ADC_SAFETY_CHECKSTATUS_RES1READY_MASK|\
                                     CSL_ADC_SAFETY_CHECKSTATUS_RES2READY_MASK|\
                                     CSL_ADC_SAFETY_CHECKSTATUS_OOT_MASK)
//*****************************************************************************
//
// Values that can be passed to ADC_enablePPBEvent(), ADC_disablePPBEvent(),
// ADC_enablePPBEventInterrupt(), ADC_disablePPBEventInterrupt(), and
// ADC_clearPPBEventStatus() as the intFlags and evtFlags parameters. They also
// make up the enumerated bit field returned by ADC_getPPBEventStatus().
//
//*****************************************************************************
#define ADC_EVT_TRIPHI    (0x0001U) 
#define ADC_EVT_TRIPLO    (0x0002U) 
#define ADC_EVT_ZERO    (0x0004U) 
 
//*****************************************************************************
//
// Values that can be passed to ADC_forceMultipleSOC() as socMask parameter.
// These values can be OR'd together to trigger multiple SOCs at a time.
//
//*****************************************************************************
#define ADC_FORCE_SOC0    (0x0001U)  
#define ADC_FORCE_SOC1    (0x0002U)  
#define ADC_FORCE_SOC2    (0x0004U)  
#define ADC_FORCE_SOC3    (0x0008U)  
#define ADC_FORCE_SOC4    (0x0010U)  
#define ADC_FORCE_SOC5    (0x0020U)  
#define ADC_FORCE_SOC6    (0x0040U)  
#define ADC_FORCE_SOC7    (0x0080U)  
#define ADC_FORCE_SOC8    (0x0100U)  
#define ADC_FORCE_SOC9    (0x0200U)  
#define ADC_FORCE_SOC10    (0x0400U)  
#define ADC_FORCE_SOC11    (0x0800U)  
#define ADC_FORCE_SOC12    (0x1000U)  
#define ADC_FORCE_SOC13    (0x2000U)  
#define ADC_FORCE_SOC14    (0x4000U)  
#define ADC_FORCE_SOC15    (0x8000U)  
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_CLK_DIV_1_0 = 0,  
    ADC_CLK_DIV_2_0 = 2,  
    ADC_CLK_DIV_2_5 = 3,  
    ADC_CLK_DIV_3_0 = 4,  
    ADC_CLK_DIV_3_5 = 5,  
    ADC_CLK_DIV_4_0 = 6,  
    ADC_CLK_DIV_4_5 = 7,  
    ADC_CLK_DIV_5_0 = 8,  
    ADC_CLK_DIV_5_5 = 9,  
    ADC_CLK_DIV_6_0 = 10, 
    ADC_CLK_DIV_6_5 = 11,  
    ADC_CLK_DIV_7_0 = 12,  
    ADC_CLK_DIV_7_5 = 13,  
    ADC_CLK_DIV_8_0 = 14,  
    ADC_CLK_DIV_8_5 = 15   
} ADC_ClkPrescale;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_RESOLUTION_12BIT = 0  
} ADC_Resolution;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_MODE_SINGLE_ENDED = 0,  
    ADC_MODE_DIFFERENTIAL = 1   
} ADC_SignalMode;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_TRIGGER_SW_ONLY = 0x00,  
    ADC_TRIGGER_RTI0 = 0x01,  
    ADC_TRIGGER_RTI1 = 0x02,  
    ADC_TRIGGER_RTI2 = 0x03,  
    ADC_TRIGGER_RTI3 = 0x04,  
    ADC_TRIGGER_INPUT_XBAR_OUT5 = 0x05,  
    ADC_TRIGGER_EPWM0_SOCA = 0x08,  
    ADC_TRIGGER_EPWM0_SOCB = 0x09,  
    ADC_TRIGGER_EPWM1_SOCA = 0x0A,  
    ADC_TRIGGER_EPWM1_SOCB = 0x0B,  
    ADC_TRIGGER_EPWM2_SOCA = 0x0C,  
    ADC_TRIGGER_EPWM2_SOCB = 0x0D,  
    ADC_TRIGGER_EPWM3_SOCA = 0x0E,  
    ADC_TRIGGER_EPWM3_SOCB = 0x0F,  
    ADC_TRIGGER_EPWM4_SOCA = 0x10,  
    ADC_TRIGGER_EPWM4_SOCB = 0x11,  
    ADC_TRIGGER_EPWM5_SOCA = 0x12,  
    ADC_TRIGGER_EPWM5_SOCB = 0x13,  
    ADC_TRIGGER_EPWM6_SOCA = 0x14,  
    ADC_TRIGGER_EPWM6_SOCB = 0x15,  
    ADC_TRIGGER_EPWM7_SOCA = 0x16,  
    ADC_TRIGGER_EPWM7_SOCB = 0x17,  
    ADC_TRIGGER_EPWM8_SOCA = 0x18,  
    ADC_TRIGGER_EPWM8_SOCB = 0x19,  
    ADC_TRIGGER_EPWM9_SOCA = 0x1A,  
    ADC_TRIGGER_EPWM9_SOCB = 0x1B,  
    ADC_TRIGGER_EPWM10_SOCA = 0x1C,  
    ADC_TRIGGER_EPWM10_SOCB = 0x1D,  
    ADC_TRIGGER_EPWM11_SOCA = 0x1E,  
    ADC_TRIGGER_EPWM11_SOCB = 0x1F,  
    ADC_TRIGGER_EPWM12_SOCA = 0x20,  
    ADC_TRIGGER_EPWM12_SOCB = 0x21,  
    ADC_TRIGGER_EPWM13_SOCA = 0x22,  
    ADC_TRIGGER_EPWM13_SOCB = 0x23,  
    ADC_TRIGGER_EPWM14_SOCA = 0x24,  
    ADC_TRIGGER_EPWM14_SOCB = 0x25,  
    ADC_TRIGGER_EPWM15_SOCA = 0x26,  
    ADC_TRIGGER_EPWM15_SOCB = 0x27,  
    ADC_TRIGGER_EPWM16_SOCA = 0x28,  
    ADC_TRIGGER_EPWM16_SOCB = 0x29,  
    ADC_TRIGGER_EPWM17_SOCA = 0x2A,  
    ADC_TRIGGER_EPWM17_SOCB = 0x2B,  
    ADC_TRIGGER_EPWM18_SOCA = 0x2C,  
    ADC_TRIGGER_EPWM18_SOCB = 0x2D,  
    ADC_TRIGGER_EPWM19_SOCA = 0x2E,  
    ADC_TRIGGER_EPWM19_SOCB = 0x2F,  
    ADC_TRIGGER_EPWM20_SOCA = 0x30,  
    ADC_TRIGGER_EPWM20_SOCB = 0x31,  
    ADC_TRIGGER_EPWM21_SOCA = 0x32,  
    ADC_TRIGGER_EPWM21_SOCB = 0x33,  
    ADC_TRIGGER_EPWM22_SOCA = 0x34,  
    ADC_TRIGGER_EPWM22_SOCB = 0x35,  
    ADC_TRIGGER_EPWM23_SOCA = 0x36,  
    ADC_TRIGGER_EPWM23_SOCB = 0x37,  
    ADC_TRIGGER_EPWM24_SOCA = 0x38,  
    ADC_TRIGGER_EPWM24_SOCB = 0x39,  
    ADC_TRIGGER_EPWM25_SOCA = 0x3A,  
    ADC_TRIGGER_EPWM25_SOCB = 0x3B,  
    ADC_TRIGGER_EPWM26_SOCA = 0x3C,  
    ADC_TRIGGER_EPWM26_SOCB = 0x3D,  
    ADC_TRIGGER_EPWM27_SOCA = 0x3E,  
    ADC_TRIGGER_EPWM27_SOCB = 0x3F,  
    ADC_TRIGGER_EPWM28_SOCA = 0x40,  
    ADC_TRIGGER_EPWM28_SOCB = 0x41,  
    ADC_TRIGGER_EPWM29_SOCA = 0x42,  
    ADC_TRIGGER_EPWM29_SOCB = 0x43,  
    ADC_TRIGGER_EPWM30_SOCA = 0x44,  
    ADC_TRIGGER_EPWM30_SOCB = 0x45,  
    ADC_TRIGGER_EPWM31_SOCA = 0x46,  
    ADC_TRIGGER_EPWM31_SOCB = 0x47,   
    ADC_TRIGGER_ECAP0_SOCEVT = 0x48,  
    ADC_TRIGGER_ECAP1_SOCEVT = 0x49,  
    ADC_TRIGGER_ECAP2_SOCEVT = 0x4A,  
    ADC_TRIGGER_ECAP3_SOCEVT = 0x4B,  
    ADC_TRIGGER_ECAP4_SOCEVT = 0x4C,  
    ADC_TRIGGER_ECAP5_SOCEVT = 0x4D,  
    ADC_TRIGGER_ECAP6_SOCEVT = 0x4E,  
    ADC_TRIGGER_ECAP7_SOCEVT = 0x4F,  
    ADC_TRIGGER_ECAP8_SOCEVT = 0x50,  
    ADC_TRIGGER_ECAP9_SOCEVT = 0x51,  
    ADC_TRIGGER_ECAP10_SOCEVT = 0x52,  
    ADC_TRIGGER_ECAP11_SOCEVT = 0x53,  
    ADC_TRIGGER_ECAP12_SOCEVT = 0x54,  
    ADC_TRIGGER_ECAP13_SOCEVT = 0x55,  
    ADC_TRIGGER_ECAP14_SOCEVT = 0x56,  
    ADC_TRIGGER_ECAP15_SOCEVT = 0x57,  
    ADC_TRIGGER_RTI4         = 0x58,  
    ADC_TRIGGER_RTI5         = 0x59,  
    ADC_TRIGGER_RTI6         = 0x5A,  
    ADC_TRIGGER_RTI7         = 0x5B,  
    ADC_TRIGGER_REPEATER1    = 0x7E,    
    ADC_TRIGGER_REPEATER2    = 0x7F,    
} ADC_Trigger;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_CH_ADCIN0 = 0,  
    ADC_CH_ADCIN1 = 1,  
    ADC_CH_ADCIN2 = 2,  
    ADC_CH_ADCIN3 = 3,  
    ADC_CH_ADCIN4 = 4,  
    ADC_CH_ADCIN5 = 5,  
    ADC_CH_ADCIN6 = 7,  
    ADC_CH_CAL0 = 6, 
    ADC_CH_CAL1 = 7, 
    ADC_CH_ADCIN0_ADCIN1 = 0,  
    ADC_CH_ADCIN1_ADCIN0 = 1,  
    ADC_CH_ADCIN2_ADCIN3 = 2,  
    ADC_CH_ADCIN3_ADCIN2 = 3,  
    ADC_CH_ADCIN4_ADCIN5 = 4,  
    ADC_CH_ADCIN5_ADCIN4 = 5,  
    ADC_CH_CAL0_CAL1 = 6, 
    ADC_CH_CAL1_CAL0 = 7, 
    ADC_CH_CAL0_ADCIN6 = 6, 
    ADC_CH_ADCIN6_CAL0 = 7, 
} ADC_Channel;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_PULSE_END_OF_ACQ_WIN = 0,
    ADC_PULSE_END_OF_CONV = 1
} ADC_PulseMode;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_INT_NUMBER1 = 0,  
    ADC_INT_NUMBER2 = 1,  
    ADC_INT_NUMBER3 = 2,  
    ADC_INT_NUMBER4 = 3   
} ADC_IntNumber;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_PPB_NUMBER1 = 0,  
    ADC_PPB_NUMBER2 = 1,  
    ADC_PPB_NUMBER3 = 2,  
    ADC_PPB_NUMBER4 = 3   
} ADC_PPBNumber;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_SOC_NUMBER0 = 0,  
    ADC_SOC_NUMBER1 = 1,  
    ADC_SOC_NUMBER2 = 2,  
    ADC_SOC_NUMBER3 = 3,  
    ADC_SOC_NUMBER4 = 4,  
    ADC_SOC_NUMBER5 = 5,  
    ADC_SOC_NUMBER6 = 6,  
    ADC_SOC_NUMBER7 = 7,  
    ADC_SOC_NUMBER8 = 8,  
    ADC_SOC_NUMBER9 = 9,  
    ADC_SOC_NUMBER10 = 10,  
    ADC_SOC_NUMBER11 = 11,  
    ADC_SOC_NUMBER12 = 12,  
    ADC_SOC_NUMBER13 = 13,  
    ADC_SOC_NUMBER14 = 14,  
    ADC_SOC_NUMBER15 = 15   
} ADC_SOCNumber;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_INT_SOC_TRIGGER_NONE = 0,  
    ADC_INT_SOC_TRIGGER_ADCINT1 = 1,  
    ADC_INT_SOC_TRIGGER_ADCINT2 = 2   
} ADC_IntSOCTrigger;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_PRI_ALL_ROUND_ROBIN = 0,  
    ADC_PRI_SOC0_HIPRI = 1,  
    ADC_PRI_THRU_SOC1_HIPRI = 2,  
    ADC_PRI_THRU_SOC2_HIPRI = 3,  
    ADC_PRI_THRU_SOC3_HIPRI = 4,  
    ADC_PRI_THRU_SOC4_HIPRI = 5,  
    ADC_PRI_THRU_SOC5_HIPRI = 6,  
    ADC_PRI_THRU_SOC6_HIPRI = 7,  
    ADC_PRI_THRU_SOC7_HIPRI = 8,  
    ADC_PRI_THRU_SOC8_HIPRI = 9,  
    ADC_PRI_THRU_SOC9_HIPRI = 10,  
    ADC_PRI_THRU_SOC10_HIPRI = 11,  
    ADC_PRI_THRU_SOC11_HIPRI = 12,  
    ADC_PRI_THRU_SOC12_HIPRI = 13,  
    ADC_PRI_THRU_SOC13_HIPRI = 14,  
    ADC_PRI_THRU_SOC14_HIPRI = 15,  
    ADC_PRI_ALL_HIPRI = 16  
} ADC_PriorityMode;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_OSDETECT_MODE_DISABLED            = 0x0U,
    ADC_OSDETECT_MODE_VSSA                = 0x1U,
    ADC_OSDETECT_MODE_VDDA                = 0x2U,
    ADC_OSDETECT_MODE_5BY12_VDDA          = 0x3U,
    ADC_OSDETECT_MODE_7BY12_VDDA          = 0x4U,
    ADC_OSDETECT_MODE_5K_PULLDOWN_TO_VSSA = 0x5U,
    ADC_OSDETECT_MODE_5K_PULLUP_TO_VDDA   = 0x6U,
    ADC_OSDETECT_MODE_7K_PULLDOWN_TO_VSSA = 0x7U 
} ADC_OSDetectMode;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_OFFSET_TRIM_COMMON     = 0x0000U, 
    ADC_OFFSET_TRIM_INDIVIDUAL = 0x0100U  
} ADC_OffsetTrim;
 
typedef enum
{
    ADC_SYNCIN_DISABLE          = 0x00,  
    ADC_SYNCIN_EPWM0SYNCOUT     = 0x01,  
    ADC_SYNCIN_EPWM1SYNCOUT     = 0x02,  
    ADC_SYNCIN_EPWM2SYNCOUT     = 0x03,  
    ADC_SYNCIN_EPWM3SYNCOUT     = 0x04,  
    ADC_SYNCIN_EPWM4SYNCOUT     = 0x05,  
    ADC_SYNCIN_EPWM5SYNCOUT     = 0x06,  
    ADC_SYNCIN_EPWM6SYNCOUT     = 0x07,  
    ADC_SYNCIN_EPWM7SYNCOUT     = 0x08,  
    ADC_SYNCIN_EPWM8SYNCOUT     = 0x09,  
    ADC_SYNCIN_EPWM9SYNCOUT     = 0x0A,  
    ADC_SYNCIN_EPWM10SYNCOUT    = 0x0B,  
    ADC_SYNCIN_EPWM11SYNCOUT    = 0x0C,  
    ADC_SYNCIN_EPWM12SYNCOUT    = 0x0D,  
    ADC_SYNCIN_EPWM13SYNCOUT    = 0x0E,  
    ADC_SYNCIN_EPWM14SYNCOUT    = 0x0F,  
    ADC_SYNCIN_EPWM15SYNCOUT    = 0x10,  
    ADC_SYNCIN_EPWM16SYNCOUT    = 0x11,  
    ADC_SYNCIN_EPWM17SYNCOUT    = 0x12,  
    ADC_SYNCIN_EPWM18SYNCOUT    = 0x13,  
    ADC_SYNCIN_EPWM19SYNCOUT    = 0x14,  
    ADC_SYNCIN_EPWM20SYNCOUT    = 0x15,  
    ADC_SYNCIN_EPWM21SYNCOUT    = 0x16,  
    ADC_SYNCIN_EPWM22SYNCOUT    = 0x17,  
    ADC_SYNCIN_EPWM23SYNCOUT    = 0x18,  
    ADC_SYNCIN_EPWM24SYNCOUT    = 0x19,  
    ADC_SYNCIN_EPWM25SYNCOUT    = 0x1A,  
    ADC_SYNCIN_EPWM26SYNCOUT    = 0x1B,  
    ADC_SYNCIN_EPWM27SYNCOUT    = 0x1C,  
    ADC_SYNCIN_EPWM28SYNCOUT    = 0x1D,  
    ADC_SYNCIN_EPWM29SYNCOUT    = 0x1E,  
    ADC_SYNCIN_EPWM30SYNCOUT    = 0x1F,  
    ADC_SYNCIN_EPWM31SYNCOUT    = 0x20,  
    ADC_SYNCIN_ECAP0SYNCOUT     = 0x21,  
    ADC_SYNCIN_ECAP1SYNCOUT     = 0x22,  
    ADC_SYNCIN_ECAP2SYNCOUT     = 0x23,  
    ADC_SYNCIN_ECAP3SYNCOUT     = 0x24,  
    ADC_SYNCIN_ECAP4SYNCOUT     = 0x25,  
    ADC_SYNCIN_ECAP5SYNCOUT     = 0x26,  
    ADC_SYNCIN_ECAP6SYNCOUT     = 0x27,  
    ADC_SYNCIN_ECAP7SYNCOUT     = 0x28,  
    ADC_SYNCIN_ECAP8SYNCOUT     = 0x29,  
    ADC_SYNCIN_ECAP9SYNCOUT     = 0x2A,  
    ADC_SYNCIN_ECAP10SYNCOUT    = 0x2B,  
    ADC_SYNCIN_ECAP11SYNCOUT    = 0x2C,  
    ADC_SYNCIN_ECAP12SYNCOUT    = 0x2D,  
    ADC_SYNCIN_ECAP13SYNCOUT    = 0x2E,  
    ADC_SYNCIN_ECAP14SYNCOUT    = 0x2F,  
    ADC_SYNCIN_ECAP15SYNCOUT    = 0x30,  
    ADC_SYNCIN_INPUTXBAROUTPUT6 = 0x31,  
    ADC_SYNCIN_INPUTXBAROUTPUT7 = 0x32,  
    ADC_SYNCIN_CPSW_CTPS_SYNC    = 0x33,  
} ADC_SyncInput;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_PPB_OS_INT_1 = 0x0U,          
    ADC_PPB_OS_INT_2 = 0x1U           
} ADC_PPBIntSrcSelect;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_CH_ADCINX_0  = 0x0,          
    ADC_CH_ADCINX_1  = 0x1,          
    ADC_CH_ADCINX_2  = 0x2,          
    ADC_CH_ADCINX_3  = 0x3,          
} ADC_ExtChannel;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_INT_TRIGGER_EOC0   = 0,        
    ADC_INT_TRIGGER_EOC1   = 1,        
    ADC_INT_TRIGGER_EOC2   = 2,        
    ADC_INT_TRIGGER_EOC3   = 3,        
    ADC_INT_TRIGGER_EOC4   = 4,        
    ADC_INT_TRIGGER_EOC5   = 5,        
    ADC_INT_TRIGGER_EOC6   = 6,        
    ADC_INT_TRIGGER_EOC7   = 7,        
    ADC_INT_TRIGGER_EOC8   = 8,        
    ADC_INT_TRIGGER_EOC9   = 9,        
    ADC_INT_TRIGGER_EOC10  = 10,       
    ADC_INT_TRIGGER_EOC11  = 11,       
    ADC_INT_TRIGGER_EOC12  = 12,       
    ADC_INT_TRIGGER_EOC13  = 13,       
    ADC_INT_TRIGGER_EOC14  = 14,       
    ADC_INT_TRIGGER_EOC15  = 15,       
    ADC_INT_TRIGGER_OSINT1 = 16,       
    ADC_INT_TRIGGER_OSINT2 = 17,       
    ADC_INT_TRIGGER_OSINT3 = 18,       
    ADC_INT_TRIGGER_OSINT4 = 19        
} ADC_IntTrigger;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_PPB_COMPSOURCE_RESULT = 0x0,   
    ADC_PPB_COMPSOURCE_PSUM   = 0x1,   
    ADC_PPB_COMPSOURCE_SUM    = 0x2    
} ADC_PPBCompSource;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
     ADC_0 = 0,                        
     ADC_1 = 1,                        
     ADC_2 = 2,                         
     ADC_3 = 3,                         
     ADC_4 = 4                         
} ADC_Select;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_RESULT0  = 0,                  
    ADC_RESULT1  = 1,                  
    ADC_RESULT2  = 2,                  
    ADC_RESULT3  = 3,                  
    ADC_RESULT4  = 4,                  
    ADC_RESULT5  = 5,                  
    ADC_RESULT6  = 6,                  
    ADC_RESULT7  = 7,                  
    ADC_RESULT8  = 8,                  
    ADC_RESULT9  = 9,                  
    ADC_RESULT10 = 10,                 
    ADC_RESULT11 = 11,                 
    ADC_RESULT12 = 12,                 
    ADC_RESULT13 = 13,                 
    ADC_RESULT14 = 14,                 
    ADC_RESULT15 = 15                  
} ADC_ResultSelect;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_SAFETY_CHECKER_INPUT_DISABLE  = 0x0, 
    ADC_SAFETY_CHECKER_INPUT_SOCx     = 0x1, 
    ADC_SAFETY_CHECKER_INPUT_PPBx     = 0x2, 
    ADC_SAFETY_CHECKER_INPUT_PPBSUMx  = 0x3  
} ADC_SafetyCheckerInput;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
  ADC_SAFETY_CHECK1  = 0x0,            
  ADC_SAFETY_CHECK2  = 0x4             
} ADC_SafetyCheckInst;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_SAFETY_CHECK_EVENT1 = 0,       
    ADC_SAFETY_CHECK_EVENT2 = 16,       
    ADC_SAFETY_CHECK_EVENT3 = 32,      
    ADC_SAFETY_CHECK_EVENT4 = 48       
} ADC_SafetyCheckEvent;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_SAFETY_CHECK_RES1OVF = 0,      
    ADC_SAFETY_CHECK_RES2OVF = 4,      
    ADC_SAFETY_CHECK_OOT     = 8       
} ADC_SafetyCheckResult;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_SAFETY_CHECKER1 = 0,           
    ADC_SAFETY_CHECKER2 = 1,           
    ADC_SAFETY_CHECKER3 = 2,           
    ADC_SAFETY_CHECKER4 = 3,           
    ADC_SAFETY_CHECKER5 = 4,           
    ADC_SAFETY_CHECKER6 = 5,           
    ADC_SAFETY_CHECKER7 = 6,           
    ADC_SAFETY_CHECKER8 = 7,            
    ADC_SAFETY_CHECKER9 = 8,            
    ADC_SAFETY_CHECKER10 = 9,            
    ADC_SAFETY_CHECKER11 = 10,            
    ADC_SAFETY_CHECKER12 = 11            
}ADC_Checker;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_SAFETY_CHECK_OOT_FLG     = 0,  
    ADC_SAFETY_CHECK_RES1OVF_FLG = 4,  
    ADC_SAFETY_CHECK_RES2OVF_FLG = 8   
}ADC_SafetyCheckFlag;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_REPINST1 = 0x0,                
    ADC_REPINST2 = 0x1                 
} ADC_RepInstance;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    ADC_REPMODE_OVERSAMPLING   = 0x0,  
    ADC_REPMODE_UNDERSAMPLING  = 0x1   
} ADC_RepMode;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef struct
{
    ADC_RepMode repMode;     
    ADC_Trigger repTrigger;  
    ADC_SyncInput repSyncin; 
    uint16_t repCount;       
    uint16_t repPhase;       
    uint16_t repSpread;      
} ADC_RepeaterConfig;
 
//*****************************************************************************
//
//
//*****************************************************************************
#define ADC_ADCSOCxCTL_STEP (CSL_ADC_ADCSOC1CTL - CSL_ADC_ADCSOC0CTL)
#define ADC_ADCINTSELxNy_STEP (CSL_ADC_ADCINTSEL3N4 - CSL_ADC_ADCINTSEL1N2)
#define ADC_ADCPPBx_STEP (CSL_ADC_ADCPPB2CONFIG - CSL_ADC_ADCPPB1CONFIG)
#define ADC_ADCPPBTRIP_MASK ((uint32_t)CSL_ADC_ADCPPB1TRIPHI_LIMITHI_MASK \
                               | (uint32_t)CSL_ADC_ADCPPB1TRIPHI_HSIGN_MASK)
#define ADC_RESULT_ADCPPBxRESULT_STEP (CSL_ADC_RESULT_ADCPPB2RESULT -\
                                                CSL_ADC_RESULT_ADCPPB1RESULT)
#define ADC_RESULT_ADCRESULTx_STEP (CSL_ADC_RESULT_ADCRESULT1 - \
                                        CSL_ADC_RESULT_ADCRESULT0)
 
//*****************************************************************************
//
// Prototypes for the APIs.
//
//*****************************************************************************
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_setPrescaler(uint32_t base, ADC_ClkPrescale clkPrescale)
{
    //
    // Set the configuration of the ADC module prescaler.
    //
    HW_WR_REG16(base + CSL_ADC_ADCCTL2,
        ((HW_RD_REG16(base + CSL_ADC_ADCCTL2) &
        ~CSL_ADC_ADCCTL2_PRESCALE_MASK) | (uint16_t)clkPrescale));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_setupSOC(uint32_t base, ADC_SOCNumber socNumber, ADC_Trigger trigger,
             ADC_Channel channel, uint32_t sampleWindow)
{
    uint32_t ctlRegAddr;
 
    //
    // Check the arguments.
    //
    DebugP_assert((sampleWindow >= 16U) && (sampleWindow <= 512U));
 
    //
    // Calculate address for the SOC control register.
    //
    ctlRegAddr = base + CSL_ADC_ADCSOC0CTL +
        ((uint32_t)socNumber * ADC_ADCSOCxCTL_STEP);
 
    //
    // Set the configuration of the specified SOC.
    //
    HW_WR_REG32(ctlRegAddr,
        (((uint32_t)channel << CSL_ADC_ADCSOC0CTL_CHSEL_SHIFT) |
        ((uint32_t)trigger << CSL_ADC_ADCSOC0CTL_TRIGSEL_SHIFT) |
        (sampleWindow - 1U)));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_selectSOCExtChannel(uint32_t base, ADC_SOCNumber socNumber,
                        uint16_t extChannel)
{
    uint32_t ctlRegAddr;
 
    //
    // Check the arguments.
    //
    DebugP_assert(extChannel <= 3U);
 
    //
    // Calculate address for the SOC control register.
    //
    ctlRegAddr = base + CSL_ADC_ADCSOC0CTL +
        ((uint32_t)socNumber * ADC_ADCSOCxCTL_STEP);
 
    //
    // Set the external channel configuration of the specified SOC.
    //
    HW_WR_REG32(ctlRegAddr,
        ((HW_RD_REG32(ctlRegAddr) & ~((uint32_t)CSL_ADC_ADCSOC0CTL_EXTCHSEL_MASK)) |
        ((uint32_t)extChannel << CSL_ADC_ADCSOC0CTL_EXTCHSEL_SHIFT)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_forceRepeaterTrigger(uint32_t base, uint16_t repInstance)
{
    uint32_t regOffset;
 
    regOffset = base + (repInstance * (ADC_REPxCTL_STEP));
 
    //
    // Triggers the selected repeater instance
    //
    HW_WR_REG16(regOffset + CSL_ADC_REP1FRC,
        ((HW_RD_REG16(regOffset + CSL_ADC_REP1FRC) |
        CSL_ADC_REP1FRC_SWFRC_MASK)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint16_t
ADC_getRepeaterStatus(uint32_t base, uint16_t repInstance)
{
    uint32_t regOffset;
 
    regOffset = base + (repInstance * (ADC_REPxCTL_STEP));
 
    //
    // Return the status of repeater.
    //
    return(HW_RD_REG16(regOffset + CSL_ADC_REP1CTL) & ADC_REPSTATUS_MASK);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_setInterruptSOCTrigger(uint32_t base, ADC_SOCNumber socNumber,
                           ADC_IntSOCTrigger trigger)
{
    uint16_t shiftVal;
 
    //
    // Each SOC has a 2-bit field in this register.
    //
    shiftVal = (uint16_t)socNumber << 1U;
 
    //
    // Set the configuration of the specified SOC. Note that we're treating
    // ADCINTSOCSEL1 and ADCINTSOCSEL2 as one 32-bit register here.
    //
    HW_WR_REG32(base + CSL_ADC_ADCINTSOCSEL1,
        ((HW_RD_REG32(base + CSL_ADC_ADCINTSOCSEL1) &
        ~((uint32_t)CSL_ADC_ADCINTSOCSEL1_SOC0_MASK << shiftVal)) |
        ((uint32_t)trigger << shiftVal)));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_setInterruptPulseMode(uint32_t base, ADC_PulseMode pulseMode)
{
    //
    // Set the position of the pulse.
    //
    HW_WR_REG16(base + CSL_ADC_ADCCTL1,
        ((HW_RD_REG16(base + CSL_ADC_ADCCTL1) &
        ~CSL_ADC_ADCCTL1_INTPULSEPOS_MASK) |
        ((uint16_t)pulseMode<<CSL_ADC_ADCCTL1_INTPULSEPOS_SHIFT)));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_setInterruptCycleOffset(uint32_t base, uint16_t cycleOffset)
{
    //
    // Set the position of the pulse.
    //
    HW_WR_REG16(base + CSL_ADC_ADCINTCYCLE, cycleOffset);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_enableAltDMATiming(uint32_t base)
{
 
    //
    // Enable the Alternate DMA timings wherein DMA is triggered
    // at tDMA.
    //
    HW_WR_REG16(base + CSL_ADC_ADCCTL1,
        (HW_RD_REG16(base + CSL_ADC_ADCCTL1) | CSL_ADC_ADCCTL1_TDMAEN_MASK));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_disableAltDMATiming(uint32_t base)
{
 
    //
    // Disable the Alternate DMA timings wherein DMA is triggered at the same
    // time as CPU interrupt.
    //
    HW_WR_REG16(base + CSL_ADC_ADCCTL1,
        (HW_RD_REG16(base + CSL_ADC_ADCCTL1) & ~CSL_ADC_ADCCTL1_TDMAEN_MASK));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_enableExtMuxPreselect(uint32_t base)
{
 
    //
    // Enable the external mux selection at the end of S+H window of
    // previous conversion.
    //
    HW_WR_REG16(base + CSL_ADC_ADCCTL1,
        (HW_RD_REG16(base + CSL_ADC_ADCCTL1) |
        CSL_ADC_ADCCTL1_EXTMUXPRESELECTEN_MASK));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_disableExtMuxPreselect(uint32_t base)
{
 
    //
    // Enable the external mux selection at the beginning of S+H window of
    // current conversion.
    //
    HW_WR_REG16(base + CSL_ADC_ADCCTL1,
        (HW_RD_REG16(base + CSL_ADC_ADCCTL1) &
        ~CSL_ADC_ADCCTL1_EXTMUXPRESELECTEN_MASK));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_selectOffsetTrimMode(uint32_t base, ADC_OffsetTrim mode)
{
 
    //
    // Enable the external mux selection at the end of S+H window of
    // previous conversion.
    //
    HW_WR_REG16(base + CSL_ADC_ADCCTL2,
        ((HW_RD_REG16(base + CSL_ADC_ADCCTL2) &
        ~CSL_ADC_ADCCTL2_OFFTRIMMODE_MASK) | (uint16_t)mode));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline bool
ADC_getIntResultStatus(uint32_t base, ADC_IntNumber adcIntNum)
{
 
    //
    // Get the specified ADC interrupt result ready status.
    //
    return((HW_RD_REG16(base + CSL_ADC_ADCINTFLG) &
                 (1U << ((uint16_t)adcIntNum + 4U))) != 0U);
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_enableConverter(uint32_t base)
{
    //
    // Set the bit that powers up the analog circuitry.
    //
    HW_WR_REG16(base + CSL_ADC_ADCCTL1,
        (HW_RD_REG16(base + CSL_ADC_ADCCTL1) | CSL_ADC_ADCCTL1_ADCPWDNZ_MASK));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_disableConverter(uint32_t base)
{
    //
    // Clear the bit that powers down the analog circuitry.
    //
    HW_WR_REG16(base + CSL_ADC_ADCCTL1,
        (HW_RD_REG16(base + CSL_ADC_ADCCTL1) &
        ~CSL_ADC_ADCCTL1_ADCPWDNZ_MASK));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_forceSOC(uint32_t base, ADC_SOCNumber socNumber)
{
    //
    // Write to the register that will force a 1 to the corresponding SOC flag
    //
    HW_WR_REG16(base + CSL_ADC_ADCSOCFRC1, ((uint16_t)1U << (uint16_t)socNumber));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_forceMultipleSOC(uint32_t base, uint16_t socMask)
{
    //
    // Write to the register that will force a 1 to desired SOCs
    //
    HW_WR_REG16(base + CSL_ADC_ADCSOCFRC1, socMask);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline bool
ADC_getInterruptStatus(uint32_t base, ADC_IntNumber adcIntNum)
{
    //
    // Get the specified ADC interrupt status.
    //
    return((HW_RD_REG16(base + CSL_ADC_ADCINTFLG) &
        (1U << (uint16_t)adcIntNum)) != 0U);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_clearInterruptStatus(uint32_t base, ADC_IntNumber adcIntNum)
{
    //
    // Clear the specified interrupt.
    //
    HW_WR_REG16(base + CSL_ADC_ADCINTFLGCLR, ((uint16_t)1U << (uint16_t)adcIntNum));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline bool
ADC_getInterruptOverflowStatus(uint32_t base, ADC_IntNumber adcIntNum)
{
    //
    // Get the specified ADC interrupt status.
    //
    return((HW_RD_REG16(base + CSL_ADC_ADCINTOVF) &
        (1U << (uint16_t)adcIntNum)) != 0U);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_clearInterruptOverflowStatus(uint32_t base, ADC_IntNumber adcIntNum)
{
    //
    // Clear the specified interrupt overflow bit.
    //
    HW_WR_REG16(base + CSL_ADC_ADCINTOVFCLR, ((uint16_t)1U << (uint16_t)adcIntNum));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint16_t
ADC_readResult(uint32_t resultBase, ADC_SOCNumber socNumber)
{
    //
    // Return the ADC result for the selected SOC.
    //
    return(HW_RD_REG16(resultBase + CSL_ADC_RESULT_ADCRESULT0 +
        ((uint32_t)socNumber * ADC_RESULT_ADCRESULTx_STEP)));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline bool
ADC_isBusy(uint32_t base)
{
    //
    // Determine if the ADC is busy.
    //
    return((HW_RD_REG16(base + CSL_ADC_ADCCTL1) &
        CSL_ADC_ADCCTL1_ADCBSY_MASK) != 0U);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_setBurstModeConfig(uint32_t base, ADC_Trigger trigger, uint16_t burstSize)
{
    uint16_t regValue;
 
    //
    // Check the arguments.
    //
    DebugP_assert(((uint32_t)trigger & ~0x7FU) == 0U);
    DebugP_assert((burstSize >= 1U) && (burstSize <= 16U));
 
    //
    // Write the burst mode configuration to the register.
    //
    regValue = (uint16_t)trigger |
        ((burstSize - 1U) << CSL_ADC_ADCBURSTCTL_BURSTSIZE_SHIFT);
 
    HW_WR_REG16(base + CSL_ADC_ADCBURSTCTL,
        ((HW_RD_REG16(base + CSL_ADC_ADCBURSTCTL) &
        ~((uint16_t)CSL_ADC_ADCBURSTCTL_BURSTTRIGSEL_MASK |
        CSL_ADC_ADCBURSTCTL_BURSTSIZE_MASK)) | regValue));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_enableBurstMode(uint32_t base)
{
    //
    // Enable burst mode.
    //
    HW_WR_REG16(base + CSL_ADC_ADCBURSTCTL,
        (HW_RD_REG16(base + CSL_ADC_ADCBURSTCTL) |
        CSL_ADC_ADCBURSTCTL_BURSTEN_MASK));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_disableBurstMode(uint32_t base)
{
    //
    // Disable burst mode.
    //
    HW_WR_REG16(base + CSL_ADC_ADCBURSTCTL,
        (HW_RD_REG16(base + CSL_ADC_ADCBURSTCTL) &
        ~CSL_ADC_ADCBURSTCTL_BURSTEN_MASK));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_setSOCPriority(uint32_t base, ADC_PriorityMode priMode)
{
    //
    // Set SOC priority
    //
    HW_WR_REG16(base + CSL_ADC_ADCSOCPRICTL,
        ((HW_RD_REG16(base + CSL_ADC_ADCSOCPRICTL) &
        ~CSL_ADC_ADCSOCPRICTL_SOCPRIORITY_MASK) | (uint16_t)priMode));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_configOSDetectMode(uint32_t base, ADC_OSDetectMode modeVal)
{
    //
    // Configure open/shorts detection circuit mode.
    //
    HW_WR_REG16(base + CSL_ADC_ADCOSDETECT,
        ((HW_RD_REG16(base + CSL_ADC_ADCOSDETECT) &
        ~CSL_ADC_ADCOSDETECT_DETECTCFG_MASK) | (uint16_t)modeVal));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_setupPPB(uint32_t base, ADC_PPBNumber ppbNumber, ADC_SOCNumber socNumber)
{
    uint32_t ppbOffset;
 
    //
    // Get the offset to the appropriate PPB configuration register.
    //
    ppbOffset = (ADC_ADCPPBx_STEP * (uint32_t)ppbNumber) +
        CSL_ADC_ADCPPB1CONFIG;
 
    //
    // Write the configuration to the register.
    //
    HW_WR_REG16(base + ppbOffset,
        ((HW_RD_REG16(base + ppbOffset) & ~CSL_ADC_ADCPPB1CONFIG_CONFIG_MASK) |
        ((uint16_t)socNumber & CSL_ADC_ADCPPB1CONFIG_CONFIG_MASK)));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_enablePPBEvent(uint32_t base, ADC_PPBNumber ppbNumber, uint16_t evtFlags)
{
    //
    // Check the arguments.
    //
    DebugP_assert((evtFlags & ~0x7U) == 0U);
 
    //
    // Enable the specified event.
    //
    HW_WR_REG16(base + CSL_ADC_ADCEVTSEL,
        (HW_RD_REG16(base + CSL_ADC_ADCEVTSEL) |
        (evtFlags << ((uint16_t)ppbNumber * 4U))));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_disablePPBEvent(uint32_t base, ADC_PPBNumber ppbNumber, uint16_t evtFlags)
{
    //
    // Check the arguments.
    //
    DebugP_assert((evtFlags & ~0x7U) == 0U);
 
    //
    // Disable the specified event.
    //
    HW_WR_REG16(base + CSL_ADC_ADCEVTSEL,
        (HW_RD_REG16(base + CSL_ADC_ADCEVTSEL) &
        ~(evtFlags << ((uint16_t)ppbNumber * 4U))));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_enablePPBEventInterrupt(uint32_t base, ADC_PPBNumber ppbNumber,
                            uint16_t intFlags)
{
    //
    // Check the arguments.
    //
    DebugP_assert((intFlags & ~0x7U) == 0U);
 
    //
    // Enable the specified event interrupts.
    //
    HW_WR_REG16(base + CSL_ADC_ADCEVTINTSEL,
        (HW_RD_REG16(base + CSL_ADC_ADCEVTINTSEL) |
        (intFlags << ((uint16_t)ppbNumber * 4U))));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_disablePPBEventInterrupt(uint32_t base, ADC_PPBNumber ppbNumber,
                             uint16_t intFlags)
{
    //
    // Check the arguments.
    //
    DebugP_assert((intFlags & ~0x7U) == 0U);
 
    //
    // Disable the specified event interrupts.
    //
    HW_WR_REG16(base + CSL_ADC_ADCEVTINTSEL,
        (HW_RD_REG16(base + CSL_ADC_ADCEVTINTSEL) &
        ~(intFlags << ((uint16_t)ppbNumber * 4U))));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint16_t
ADC_getPPBEventStatus(uint32_t base, ADC_PPBNumber ppbNumber)
{
    //
    // Get the event status for the specified post-processing block.
    //
    return((HW_RD_REG16(base + CSL_ADC_ADCEVTSTAT) >>
        ((uint16_t)ppbNumber * 4U)) & 0x7U);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_clearPPBEventStatus(uint32_t base, ADC_PPBNumber ppbNumber,
                        uint16_t evtFlags)
{
    //
    // Check the arguments.
    //
    DebugP_assert((evtFlags & ~0x7U) == 0U);
 
    //
    // Clear the specified event interrupts.
    //
    HW_WR_REG16(base + CSL_ADC_ADCEVTCLR,
        (HW_RD_REG16(base + CSL_ADC_ADCEVTCLR) |
        (evtFlags << ((uint16_t)ppbNumber * 4U))));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_enablePPBEventCBCClear(uint32_t base, ADC_PPBNumber ppbNumber)
{
    uint32_t ppbOffset;
 
    //
    // Get the offset to the appropriate PPB configuration register.
    //
    ppbOffset = (ADC_ADCPPBx_STEP * (uint32_t)ppbNumber) +
                    CSL_ADC_ADCPPB1CONFIG;
 
    //
    // Set automatic cycle-by-cycle flag clear bit
    //
    HW_WR_REG16(base + ppbOffset,
        (HW_RD_REG16(base + ppbOffset) | CSL_ADC_ADCPPB1CONFIG_CBCEN_MASK));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_disablePPBEventCBCClear(uint32_t base, ADC_PPBNumber ppbNumber)
{
    uint32_t ppbOffset;
 
    //
    // Get the offset to the appropriate PPB configuration register.
    //
    ppbOffset = (ADC_ADCPPBx_STEP * (uint32_t)ppbNumber) +
                    CSL_ADC_ADCPPB1CONFIG;
 
    //
    // Clear automatic cycle-by-cycle flag clear bit
    //
    HW_WR_REG16(base + ppbOffset,
        (HW_RD_REG16(base + ppbOffset) & ~CSL_ADC_ADCPPB1CONFIG_CBCEN_MASK));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_setPPBCountLimit(uint32_t base, ADC_PPBNumber ppbNumber, uint16_t limit)
{
    uint32_t ppbOffset;
 
    //
    // Check the arguments.
    //
    DebugP_assert(limit <= CSL_ADC_ADCPPB1LIMIT_LIMIT_MAX);
 
    //
    // Get the offset to the appropriate PPB configuration register.
    //
    ppbOffset = (ADC_ADCPPBxLIMIT_STEP * (uint32_t)ppbNumber) +
                    CSL_ADC_ADCPPB1LIMIT;
 
    //
    // Enable PPB two's complement.
    //
    HW_WR_REG16(base + ppbOffset,
        ((HW_RD_REG16(base + ppbOffset) & ~CSL_ADC_ADCPPB1LIMIT_LIMIT_MASK) |
        (limit << CSL_ADC_ADCPPB1LIMIT_LIMIT_SHIFT)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint16_t
ADC_getPPBCountLimit(uint32_t base, ADC_PPBNumber ppbNumber)
{
    uint16_t limit;
    uint32_t ppbOffset;
 
    //
    // Get the offset to the appropriate PPB configuration register.
    //
    ppbOffset = (ADC_ADCPPBxLIMIT_STEP * (uint32_t)ppbNumber) +
                    CSL_ADC_ADCPPB1LIMIT;
 
    limit = (HW_RD_REG16(base + ppbOffset) &
        ~(CSL_ADC_ADCPPB1LIMIT_LIMIT_MASK)) >> CSL_ADC_ADCPPB1LIMIT_LIMIT_SHIFT;
    return(limit);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint16_t
ADC_readPPBPCount(uint32_t base, ADC_PPBNumber ppbNumber)
{
 
    //
    // Returns the partial count of the selected PPB.
    //
    return(HW_RD_REG32(base + (uint32_t)CSL_ADC_ADCPPBP1PCOUNT +
            ((uint32_t)ppbNumber * ADC_ADCPPBxPCOUNT_STEP)));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline int32_t
ADC_readPPBPSum(uint32_t base, ADC_PPBNumber ppbNumber)
{
 
    //
    // Returns the partial sum result of selected PPB.
    //
    return(HW_RD_REG32(base + (uint32_t)CSL_ADC_ADCPPB1PSUM +
            ((uint32_t)ppbNumber * ADC_ADCPPBxPSUM_STEP)));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline int32_t
ADC_readPPBPMax(uint32_t base, ADC_PPBNumber ppbNumber)
{
 
    //
    // Return the partial maximum value of selected PPB.
    //
    return(HW_RD_REG32(base + (uint32_t)CSL_ADC_ADCPPB1PMAX +
            ((uint32_t)ppbNumber * ADC_ADCPPBxPMAX_STEP)));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline int32_t
ADC_readPPBPMin(uint32_t base, ADC_PPBNumber ppbNumber)
{
 
    //
    // Return the partial minimum value of selected PPB.
    //
    return(HW_RD_REG32(base + (uint32_t)CSL_ADC_ADCPPB1PMIN +
            ((uint32_t)ppbNumber * ADC_ADCPPBxPMIN_STEP)));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint16_t
ADC_readPPBPMaxIndex(uint32_t base, ADC_PPBNumber ppbNumber)
{
 
    //
    // Returns the index of the partial maximum value of selected PPB.
    //
    return(HW_RD_REG32(base + (uint32_t)CSL_ADC_ADCPPB1PMAXI +
            ((uint32_t)ppbNumber * ADC_ADCPPBxPMAXI_STEP)));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint16_t
ADC_readPPBPMinIndex(uint32_t base, ADC_PPBNumber ppbNumber)
{
 
    //
    // Returns the index of the partial minimum value of selected PPB.
    //
    return(HW_RD_REG32(base + (uint32_t)CSL_ADC_ADCPPB1PMINI +
            ((uint32_t)ppbNumber * ADC_ADCPPBxPMINI_STEP)));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_enablePPBAbsoluteValue(uint32_t base, ADC_PPBNumber ppbNumber)
{
    uint32_t ppbOffset;
 
    //
    // Get the offset to the appropriate PPB configuration register.
    //
    ppbOffset = (ADC_ADCPPBx_STEP * (uint32_t)ppbNumber) +
                    CSL_ADC_ADCPPB1CONFIG;
 
    //
    // Enable PPB absolute value.
    //
    HW_WR_REG16(base + ppbOffset,
        (HW_RD_REG16(base + ppbOffset) | CSL_ADC_ADCPPB1CONFIG_ABSEN_MASK));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_disablePPBAbsoluteValue(uint32_t base, ADC_PPBNumber ppbNumber)
{
    uint32_t ppbOffset;
 
    //
    // Get the offset to the appropriate PPB configuration register.
    //
    ppbOffset = (ADC_ADCPPBx_STEP * (uint32_t)ppbNumber) +
                    CSL_ADC_ADCPPB1CONFIG;
 
    //
    // Disable PPB abosulte value.
    //
    HW_WR_REG16(base + ppbOffset,
        (HW_RD_REG16(base + ppbOffset) & ~CSL_ADC_ADCPPB1CONFIG_ABSEN_MASK));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_setPPBShiftValue(uint32_t base, ADC_PPBNumber ppbNumber, uint16_t shiftVal)
{
    uint32_t ppbOffset;
 
    //
    // Check the arguments.
    //
    DebugP_assert(shiftVal <= 10U);
 
    //
    // Get the offset to the appropriate PPB configuration register.
    //
    ppbOffset = (ADC_ADCPPBxCONFIG2_STEP * (uint32_t)ppbNumber) +
                    CSL_ADC_ADCPPB1CONFIG2;
 
    //
    // Configure shift value for the PPB.
    //
    HW_WR_REG16(base + ppbOffset,
        ((HW_RD_REG16(base + ppbOffset) & ~CSL_ADC_ADCPPB1CONFIG2_SHIFT_MASK) |
        (shiftVal << CSL_ADC_ADCPPB1CONFIG2_SHIFT_SHIFT)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_selectPPBSyncInput(uint32_t base, ADC_PPBNumber ppbNumber,
                       uint16_t syncInput)
{
    uint32_t ppbOffset;
 
    //
    // Get the offset to the appropriate PPB configuration register.
    //
    ppbOffset = (ADC_ADCPPBxCONFIG2_STEP * (uint32_t)ppbNumber) +
                    CSL_ADC_ADCPPB1CONFIG2;
 
    //
    // Select sync input for the PPB.
    //
    HW_WR_REG16(base + ppbOffset,
        ((HW_RD_REG16(base + ppbOffset) & ~CSL_ADC_ADCPPB1CONFIG2_SYNCINSEL_MASK) |
        (syncInput << CSL_ADC_ADCPPB1CONFIG2_SYNCINSEL_SHIFT)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_forcePPBSync(uint32_t base, ADC_PPBNumber ppbNumber)
{
    uint32_t ppbOffset;
 
    //
    // Get the offset to the appropriate PPB configuration register.
    //
    ppbOffset = (ADC_ADCPPBxCONFIG2_STEP * (uint32_t)ppbNumber) +
                    CSL_ADC_ADCPPB1CONFIG2;
 
    //
    // Force software sync for the PPB.
    //
    HW_WR_REG16(base + ppbOffset,
        (HW_RD_REG16(base + ppbOffset) | CSL_ADC_ADCPPB1CONFIG2_SWSYNC_MASK));
 
}
 
//*****************************************************************************
//
//*****************************************************************************
static inline void
ADC_selectPPBOSINTSource(uint32_t base, ADC_PPBNumber ppbNumber,
                         uint16_t osIntSrc)
{
    uint32_t ppbOffset;
 
    //
    // Check the arguments.
    //
    DebugP_assert(osIntSrc <= 1U);
 
    //
    // Get the offset to the appropriate PPB configuration register.
    //
    ppbOffset = (ADC_ADCPPBxCONFIG2_STEP * (uint32_t)ppbNumber) +
                    CSL_ADC_ADCPPB1CONFIG2;
 
    //
    // Select PPB OSINT source.
    //
    HW_WR_REG16(base + ppbOffset,
        ((HW_RD_REG16(base + ppbOffset) &
        ~CSL_ADC_ADCPPB1CONFIG2_OSINTSEL_MASK) |
        (osIntSrc << CSL_ADC_ADCPPB1CONFIG2_OSINTSEL_SHIFT)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_selectPPBCompareSource(uint32_t base, ADC_PPBNumber ppbNumber,
                           uint16_t compSrc)
{
    uint32_t ppbOffset;
 
    //
    // Check the arguments.
    //
    DebugP_assert(compSrc <= 2U);
 
    //
    // Get the offset to the appropriate PPB configuration register.
    //
    ppbOffset = (ADC_ADCPPBxCONFIG2_STEP * (uint32_t)ppbNumber) +
                    CSL_ADC_ADCPPB1CONFIG2;
 
    //
    // Select PPB compare source..
    //
    HW_WR_REG16(base + ppbOffset,
        ((HW_RD_REG16(base + ppbOffset) & ~CSL_ADC_ADCPPB1CONFIG2_COMPSEL_MASK) |
        (compSrc << CSL_ADC_ADCPPB1CONFIG2_COMPSEL_SHIFT)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline int32_t
ADC_readPPBSum(uint32_t resultBase, ADC_PPBNumber ppbNumber)
{
 
    //
    // Return the result of selected PPB.
    //
    return(HW_RD_REG32(resultBase + (uint32_t)CSL_ADC_RESULT_ADCPPB1SUM +
            ((uint32_t)ppbNumber * 8UL)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint32_t
ADC_readPPBCount(uint32_t resultBase, ADC_PPBNumber ppbNumber)
{
 
    //
    // Return the final count of selected PPB.
    //
    return(HW_RD_REG32(resultBase + (uint32_t)CSL_ADC_RESULT_ADCPPB1COUNT +
            ((uint32_t)ppbNumber * 8UL)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline int32_t
ADC_readPPBMax(uint32_t resultBase, ADC_PPBNumber ppbNumber)
{
 
    //
    // Return the final maximum value of selected PPB.
    //
    return(HW_RD_REG32(resultBase + (uint32_t)CSL_ADC_RESULT_ADCPPB1MAX +
            ((uint32_t)ppbNumber * 16UL)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline int32_t
ADC_readPPBMin(uint32_t resultBase, ADC_PPBNumber ppbNumber)
{
 
    //
    // Return the final minimum value of selected PPB.
    //
    return(HW_RD_REG32(resultBase + (uint32_t)CSL_ADC_RESULT_ADCPPB1MIN +
            ((uint32_t)ppbNumber * 16UL)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint16_t
ADC_readPPBMaxIndex(uint32_t resultBase, ADC_PPBNumber ppbNumber)
{
 
    //
    // Returns the index of the final maximum value of selected PPB.
    //
    return(HW_RD_REG32(resultBase + (uint32_t)CSL_ADC_RESULT_ADCPPB1MAXI +
            ((uint32_t)ppbNumber * 16UL)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint16_t
ADC_readPPBMinIndex(uint32_t resultBase, ADC_PPBNumber ppbNumber)
{
 
    //
    // Returns the index of the final minimum value of the selected PPB.
    //
    return(HW_RD_REG32(resultBase + (uint32_t)CSL_ADC_RESULT_ADCPPB1MINI +
            ((uint32_t)ppbNumber * 16UL)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline int32_t
ADC_readPPBResult(uint32_t resultBase, ADC_PPBNumber ppbNumber)
{
    //
    // Return the result of selected PPB.
    //
    return((int32_t)HW_RD_REG32(resultBase + CSL_ADC_RESULT_ADCPPB1RESULT +
           ((uint32_t)ppbNumber * ADC_RESULT_ADCPPBxRESULT_STEP)));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint16_t
ADC_getPPBDelayTimeStamp(uint32_t base, ADC_PPBNumber ppbNumber)
{
    uint32_t ppbOffset;
 
    //
    // Get the offset to the appropriate delay.
    //
    ppbOffset = (ADC_ADCPPBx_STEP * (uint32_t)ppbNumber) +
        CSL_ADC_ADCPPB1STAMP;
 
    //
    // Return the delay time stamp.
    //
    return(HW_RD_REG16(base + ppbOffset) & CSL_ADC_ADCPPB1STAMP_DLYSTAMP_MASK);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_setPPBCalibrationOffset(uint32_t base, ADC_PPBNumber ppbNumber,
                            int16_t offset)
{
    uint32_t ppbOffset;
 
    //
    // Get the offset to the appropriate offset register.
    //
    ppbOffset = (ADC_ADCPPBx_STEP * (uint32_t)ppbNumber) +
        CSL_ADC_ADCPPB1OFFCAL;
 
    //
    // Write the offset amount.
    //
    HW_WR_REG16(base + ppbOffset,
        ((HW_RD_REG16(base + ppbOffset) & ~CSL_ADC_ADCPPB1OFFCAL_OFFCAL_MASK) |
        ((uint16_t)offset & CSL_ADC_ADCPPB1OFFCAL_OFFCAL_MASK)));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_setPPBReferenceOffset(uint32_t base, ADC_PPBNumber ppbNumber,
                          uint16_t offset)
{
    uint32_t ppbOffset;
 
    //
    // Get the offset to the appropriate offset register.
    //
    ppbOffset = (ADC_ADCPPBx_STEP * (uint32_t)ppbNumber) +
        CSL_ADC_ADCPPB1OFFREF;
 
    //
    // Write the offset amount.
    //
    HW_WR_REG16(base + ppbOffset, offset);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_enablePPBTwosComplement(uint32_t base, ADC_PPBNumber ppbNumber)
{
    uint32_t ppbOffset;
 
    //
    // Get the offset to the appropriate PPB configuration register.
    //
    ppbOffset = (ADC_ADCPPBx_STEP * (uint32_t)ppbNumber) +
        CSL_ADC_ADCPPB1CONFIG;
 
    //
    // Enable the twos complement
    //
    HW_WR_REG16(base + ppbOffset,
        (HW_RD_REG16(base + ppbOffset) |
        CSL_ADC_ADCPPB1CONFIG_TWOSCOMPEN_MASK));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_disablePPBTwosComplement(uint32_t base, ADC_PPBNumber ppbNumber)
{
    uint32_t ppbOffset;
 
    //
    // Get the offset to the appropriate PPB configuration register.
    //
    ppbOffset = (ADC_ADCPPBx_STEP * (uint32_t)ppbNumber) +
        CSL_ADC_ADCPPB1CONFIG;
 
    //
    // Disable the twos complement
    //
    HW_WR_REG16(base + ppbOffset,
        (HW_RD_REG16(base + ppbOffset) &
        ~CSL_ADC_ADCPPB1CONFIG_TWOSCOMPEN_MASK));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_enablePPBExtendedLowLimit(uint32_t base, ADC_PPBNumber ppbNumber)
{
    uint32_t ppbLoOffset;
 
    //
    // Get the offset to the appropriate trip limit registers.
    //
    ppbLoOffset = (ADC_PPBxTRIPLO_STEP * (uint32_t)ppbNumber) +
                  CSL_ADC_ADCPPB1TRIPLO;
 
    //
    // Enable PPB extended low limit.
    //
    HW_WR_REG32(base + ppbLoOffset,
       (HW_RD_REG32(base + ppbLoOffset) | CSL_ADC_ADCPPB1TRIPLO_LIMITLO2EN_MASK));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_disablePPBExtendedLowLimit(uint32_t base, ADC_PPBNumber ppbNumber)
{
    uint32_t ppbOffset;
 
    //
    // Get the offset to the appropriate PPB configuration register.
    //
    ppbOffset = (ADC_PPBxTRIPLO_STEP * (uint32_t)ppbNumber) +
                  CSL_ADC_ADCPPB1TRIPLO;
 
    //
    // Disable PPB extended low limit.
    //
    HW_WR_REG32(base + ppbOffset,
        (HW_RD_REG32(base + ppbOffset) &
        ~CSL_ADC_ADCPPB1TRIPLO_LIMITLO2EN_MASK));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_enableInterrupt(uint32_t base, ADC_IntNumber adcIntNum)
{
    uint32_t intRegAddr;
    uint16_t shiftVal;
 
    //
    // Each INTSEL register manages two interrupts. If the interrupt number is
    // even, we'll be accessing the upper byte and will need to shift.
    //
    intRegAddr = base + CSL_ADC_ADCINTSEL1N2 +
        (((uint32_t)adcIntNum >> 1) * ADC_ADCINTSELxNy_STEP);
    shiftVal = ((uint16_t)adcIntNum & 0x1U) << 3U;
 
    //
    // Enable the specified ADC interrupt.
    //
    HW_WR_REG16(intRegAddr,
        HW_RD_REG16(intRegAddr) |
        (CSL_ADC_ADCINTSEL1N2_INT1E_MASK << shiftVal));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_disableInterrupt(uint32_t base, ADC_IntNumber adcIntNum)
{
    uint32_t intRegAddr;
    uint16_t shiftVal;
 
    //
    // Each INTSEL register manages two interrupts. If the interrupt number is
    // even, we'll be accessing the upper byte and will need to shift.
    //
    intRegAddr = base + CSL_ADC_ADCINTSEL1N2 +
        (((uint32_t)adcIntNum >> 1) * ADC_ADCINTSELxNy_STEP);
    shiftVal = ((uint16_t)adcIntNum & 0x1U) << 3U;
 
    //
    // Disable the specified ADC interrupt.
    //
    HW_WR_REG16(intRegAddr,
        HW_RD_REG16(intRegAddr) &
        ~(CSL_ADC_ADCINTSEL1N2_INT1E_MASK << shiftVal));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_setInterruptSource(uint32_t base, ADC_IntNumber adcIntNum,
                       uint16_t intTrigger)
{
    uint32_t intRegAddr;
    uint16_t shiftVal;
 
    //
    // Each INTSEL register manages two interrupts. If the interrupt number is
    // even, we'll be accessing the upper byte and will need to shift.
    //
    intRegAddr = base + CSL_ADC_ADCINTSEL1N2 +
        (((uint32_t)adcIntNum >> 1) * ADC_ADCINTSELxNy_STEP);
    shiftVal = ((uint16_t)adcIntNum & 0x1U) << 3U;
 
    //
    // Set the specified ADC interrupt source.
    //
    HW_WR_REG16(intRegAddr,
        ((HW_RD_REG16(intRegAddr) &
        ~(CSL_ADC_ADCINTSEL1N2_INT1SEL_MASK << shiftVal)) |
        ((uint16_t)intTrigger << shiftVal)));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_enableContinuousMode(uint32_t base, ADC_IntNumber adcIntNum)
{
    uint32_t intRegAddr;
    uint16_t shiftVal;
 
    //
    // Each INTSEL register manages two interrupts. If the interrupt number is
    // even, we'll be accessing the upper byte and will need to shift.
    //
    intRegAddr = base + CSL_ADC_ADCINTSEL1N2 +
        (((uint32_t)adcIntNum >> 1) * ADC_ADCINTSELxNy_STEP);
    shiftVal = ((uint16_t)adcIntNum & 0x1U) << 3U;
 
    //
    // Enable continuous mode for the specified ADC interrupt.
    //
    HW_WR_REG16(intRegAddr,
        HW_RD_REG16(intRegAddr) |
        (CSL_ADC_ADCINTSEL1N2_INT1CONT_MASK << shiftVal));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_disableContinuousMode(uint32_t base, ADC_IntNumber adcIntNum)
{
    uint32_t intRegAddr;
    uint16_t shiftVal;
 
    //
    // Each INTSEL register manages two interrupts. If the interrupt number is
    // even, we'll be accessing the upper byte and will need to shift.
    //
    intRegAddr = base + CSL_ADC_ADCINTSEL1N2 +
        (((uint32_t)adcIntNum >> 1) * ADC_ADCINTSELxNy_STEP);
    shiftVal = ((uint16_t)adcIntNum & 0x1U) << 3U;
 
    //
    // Disable continuous mode for the specified ADC interrupt.
    //
    HW_WR_REG16(intRegAddr,
        HW_RD_REG16(intRegAddr) &
        ~(CSL_ADC_ADCINTSEL1N2_INT1CONT_MASK << shiftVal));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_configSOCSafetyCheckerInput(uint32_t base, ADC_SOCNumber socNumber,
                                ADC_SafetyCheckerInput scInput)
{
    uint32_t socShift;
 
    //
    // Calculate the SOC shift.
    //
    socShift = ((uint32_t)socNumber * 2U);
 
    //
    // Configure the Safety Checker Result mode.
    //
    HW_WR_REG32(base + CSL_ADC_ADCSAFECHECKRESEN,
        ((HW_RD_REG32(base + CSL_ADC_ADCSAFECHECKRESEN) &
        ~(CSL_ADC_ADCSAFECHECKRESEN_SOC0CHKEN_MASK << socShift)) |
        ((uint32_t)scInput << socShift)));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_enableSafetyChecker(uint32_t scBase)
{
 
    //
    // Enable the Saftey Checker module
    //
    HW_WR_REG16(scBase + CSL_ADC_SAFETY_CHECKCONFIG,
        (HW_RD_REG16(scBase + CSL_ADC_SAFETY_CHECKCONFIG) |
        CSL_ADC_SAFETY_CHECKCONFIG_CHKEN_MASK));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_disableSafetyChecker(uint32_t scBase)
{
 
    //
    // Disable the Saftey Checker module.
    //
    HW_WR_REG16(scBase + CSL_ADC_SAFETY_CHECKCONFIG,
        (HW_RD_REG16(scBase + CSL_ADC_SAFETY_CHECKCONFIG) &
        ~CSL_ADC_SAFETY_CHECKCONFIG_CHKEN_MASK));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_forceSafetyCheckerSync(uint32_t scBase)
{
 
    //
    // Force software sync for the safety checker module.
    //
    HW_WR_REG16(scBase + CSL_ADC_SAFETY_CHECKCONFIG,
        (HW_RD_REG16(scBase + CSL_ADC_SAFETY_CHECKCONFIG) |
        CSL_ADC_SAFETY_CHECKCONFIG_SWSYNC_MASK));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint16_t
ADC_getSafetyCheckerStatus(uint32_t scBase)
{
 
    //
    // Returns Safety Checker module status
    //
    return(HW_RD_REG16(scBase + CSL_ADC_SAFETY_CHECKSTATUS) &
        ADC_SAFECHECK_STATUS_MASK);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_configureSafetyChecker(uint32_t scBase, ADC_SafetyCheckInst checkInst,
                           ADC_Select adcInst, ADC_ResultSelect adcResultInst)
{
 
    //
    // Configure safety checker instance
    //
    HW_WR_REG16(scBase + CSL_ADC_SAFETY_ADCRESSEL1 + ((uint16_t)checkInst),
    ((HW_RD_REG16(scBase + CSL_ADC_SAFETY_ADCRESSEL1 + ((uint16_t)checkInst)) &
    ~(CSL_ADC_SAFETY_ADCRESSEL1_ADCSEL_MASK |
    CSL_ADC_SAFETY_ADCRESSEL1_ADCRESULTSEL_MASK)) |
    ((uint16_t)adcInst << CSL_ADC_SAFETY_ADCRESSEL1_ADCSEL_SHIFT) |
    ((uint16_t)adcResultInst << CSL_ADC_SAFETY_ADCRESSEL1_ADCRESULTSEL_SHIFT)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_setSafetyCheckerTolerance(uint32_t scBase, uint32_t tolerance)
{
    //
    // Check the arguments.
    //
    DebugP_assert(tolerance <= CSL_ADC_SAFETY_TOLERANCE_TOLERANCE_MASK);
 
    //
    // Set safety checker tolerance
    //
    HW_WR_REG32(scBase + CSL_ADC_SAFETY_TOLERANCE,
        (tolerance & CSL_ADC_SAFETY_TOLERANCE_TOLERANCE_MASK));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint32_t
ADC_getSafetyCheckerResult(uint32_t scBase, ADC_SafetyCheckInst checkInst)
{
 
    //
    // Returns the safety check result for the selected instance
    //
    return(HW_RD_REG32(scBase + CSL_ADC_SAFETY_CHECKRESULT1 +
        (uint16_t)checkInst) & CSL_ADC_SAFETY_CHECKRESULT1_RESULT_MASK);
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_enableSafetyCheckEvt(uint32_t scIntEvtBase, ADC_Checker checkerNumber,
            ADC_SafetyCheckEvent checkEvent, ADC_SafetyCheckResult checkResult)
{
 
    //
    // Enables the safety checker event source.
    //
    HW_WR_REG32(scIntEvtBase + CSL_ADC_SAFETY_AGGR_CHECKEVT1SEL1 +
        (uint32_t)checkEvent + (uint32_t)checkResult,
        (HW_RD_REG32(scIntEvtBase + CSL_ADC_SAFETY_AGGR_CHECKEVT1SEL1 +
        (uint32_t)checkEvent + (uint32_t)checkResult) |
        (1UL << (uint32_t)checkerNumber)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_disableSafetyCheckEvt(uint32_t scIntEvtBase, ADC_Checker checkerNumber,
            ADC_SafetyCheckEvent checkEvent, ADC_SafetyCheckResult checkResult)
{
 
    //
    // Disables the safety checker event source.
    //
    HW_WR_REG32(scIntEvtBase + CSL_ADC_SAFETY_AGGR_CHECKEVT1SEL1 +
        (uint32_t)checkEvent + (uint32_t)checkResult,
        (HW_RD_REG32(scIntEvtBase + CSL_ADC_SAFETY_AGGR_CHECKEVT1SEL1 +
        (uint32_t)checkEvent + (uint32_t)checkResult) &
        ~(1UL << (uint32_t)checkerNumber)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_enableSafetyCheckInt(uint32_t scIntEvtBase, ADC_Checker checkerNumber,
                         ADC_SafetyCheckResult checkResult)
{
 
    //
    // Enables the safety checker interrupt source.
    //
    HW_WR_REG32(scIntEvtBase + CSL_ADC_SAFETY_AGGR_CHECKINTSEL1 +
        (uint32_t)checkResult,(HW_RD_REG32(scIntEvtBase +
        CSL_ADC_SAFETY_AGGR_CHECKINTSEL1 + (uint32_t)checkResult) |
        (1UL << (uint32_t)checkerNumber)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_disableSafetyCheckInt(uint32_t scIntEvtBase, ADC_Checker checkerNumber,
                          ADC_SafetyCheckResult checkResult)
{
 
    //
    // Enables the safety checker interrupt source.
    //
    HW_WR_REG32(scIntEvtBase + CSL_ADC_SAFETY_AGGR_CHECKINTSEL1 +
        (uint32_t)checkResult,(HW_RD_REG32(scIntEvtBase +
        CSL_ADC_SAFETY_AGGR_CHECKINTSEL1 + (uint32_t)checkResult) &
        ~(1UL << (uint32_t)checkerNumber)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline bool
ADC_getSafetyCheckStatus(uint32_t scIntEvtBase, ADC_Checker checkerNumber,
                            ADC_SafetyCheckFlag checkerFlag)
{
 
    //
    // Get the specified safety checker event status.
    //
    return(HW_RD_REG32(scIntEvtBase + CSL_ADC_SAFETY_AGGR_OOTFLG +
        (uint32_t)checkerFlag) & (1U << (uint32_t)checkerNumber));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_clearSafetyCheckStatus(uint32_t scIntEvtBase, ADC_Checker checkerNumber,
                            ADC_SafetyCheckFlag checkerFlag)
{
 
    //
    // Clear the specified safety checker event status.
    //
    HW_WR_REG32(scIntEvtBase + CSL_ADC_SAFETY_AGGR_OOTFLGCLR +
    (uint32_t)checkerFlag, (1UL << (uint32_t)checkerNumber));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint32_t
ADC_getSafetyCheckIntStatus(uint32_t scIntEvtBase)
{
 
    //
    // Get the specified safety checker interrupt status.
    //
    return(HW_RD_REG32(scIntEvtBase + CSL_ADC_SAFETY_AGGR_CHECKINTFLG));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_clearSafetyCheckIntStatus(uint32_t scIntEvtBase)
{
 
    //
    // Clear the specified safety checker interrupt status.
    //
    HW_WR_REG32(scIntEvtBase + CSL_ADC_SAFETY_AGGR_CHECKINTFLGCLR, 1U);
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_triggerRepeaterMode(uint32_t base, uint32_t repInstance, ADC_RepMode mode)
{
    uint32_t regOffset;
 
    regOffset = base + (repInstance * (ADC_REPxCTL_STEP));
 
    //
    // Set the specified repeater trigger source to modify.
    //
    HW_WR_REG32(regOffset + CSL_ADC_REP1CTL,
        ((HW_RD_REG32(regOffset + CSL_ADC_REP1CTL) &
        ~CSL_ADC_REP1CTL_MODE_MASK) | (uint32_t)mode));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline bool
ADC_triggerRepeaterActiveMode(uint32_t base, uint32_t repInstance)
{
    uint32_t regOffset;
 
    regOffset = base + (repInstance * (ADC_REPxCTL_STEP));
 
    //
    // get the specified repeater trigger active mode status.
    //
    return(HW_RD_REG32(regOffset + CSL_ADC_REP1CTL) &
        (1U << CSL_ADC_REP1CTL_ACTIVEMODE_SHIFT));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline bool
ADC_triggerRepeaterModuleBusy(uint32_t base, uint32_t repInstance)
{
    uint32_t regOffset;
 
    regOffset = base + (repInstance * (ADC_REPxCTL_STEP));
 
    //
    // get the specified repeater trigger active mode status.
    //
    return(HW_RD_REG32(regOffset + CSL_ADC_REP1CTL) &
        (1U << CSL_ADC_REP1CTL_MODULEBUSY_SHIFT));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_triggerRepeaterSelect(uint32_t base, uint16_t repInstance,
                          ADC_Trigger trigger)
{
    uint32_t regOffset;
 
    regOffset = base + (repInstance * (ADC_REPxCTL_STEP));
 
    //
    // Set the specified repeater trigger source to modify.
    //
    HW_WR_REG32(regOffset + CSL_ADC_REP1CTL,
        ((HW_RD_REG32(regOffset + CSL_ADC_REP1CTL) &
        ~CSL_ADC_REP1CTL_TRIGGER_MASK) |
        ((uint32_t)trigger << CSL_ADC_REP1CTL_TRIGGER_SHIFT)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_triggerRepeaterSyncIn(uint32_t base, uint16_t repInstance,
                          ADC_SyncInput syncInput)
{
    uint32_t regOffset;
 
    regOffset = base + (repInstance * (ADC_REPxCTL_STEP));
 
    //
    // Set the specified trigger sync input.
    //
    HW_WR_REG32(regOffset + CSL_ADC_REP1CTL,
        ((HW_RD_REG32(regOffset + CSL_ADC_REP1CTL) &
        ~CSL_ADC_REP1CTL_SYNCINSEL_MASK) |
        ((uint32_t)syncInput << CSL_ADC_REP1CTL_SYNCINSEL_SHIFT)));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_forceRepeaterTriggerSync(uint32_t base, uint16_t repInstance)
{
    uint32_t regOffset;
 
    regOffset = base + (repInstance * (ADC_REPxCTL_STEP));
 
    //
    // Force software sync for the trigger repeater block.
    //
    HW_WR_REG32(regOffset + CSL_ADC_REP1CTL,
        (HW_RD_REG32(regOffset + CSL_ADC_REP1CTL) |
        CSL_ADC_REP1CTL_SWSYNC_MASK));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_triggerRepeaterCount(uint32_t base, uint16_t repInstance,
                          uint16_t repCount)
{
    uint32_t regOffset;
    //
    // Check the arguments.
    //
    DebugP_assert(repCount <= 127U);
 
    regOffset = base + (repInstance * (ADC_REPxN_STEP));
 
    //
    // Configure repeater count.
    //
    HW_WR_REG32(regOffset + CSL_ADC_REP1N,
        ((HW_RD_REG32(regOffset + CSL_ADC_REP1N) &
        ~CSL_ADC_REP1N_NSEL_MASK) | repCount));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_triggerRepeaterPhase(uint32_t base, uint16_t repInstance,
                          uint16_t repPhase)
{
    uint32_t regOffset;
 
    regOffset = base + (repInstance * (ADC_REPxPHASE_STEP));
 
    //
    // Configure repeater phase.
    //
    HW_WR_REG32(regOffset + CSL_ADC_REP1PHASE,
        ((HW_RD_REG32(regOffset + CSL_ADC_REP1PHASE) &
        ~CSL_ADC_REP1PHASE_PHASE_MASK) | repPhase));
 
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
ADC_triggerRepeaterSpread(uint32_t base, uint16_t repInstance,
                          uint16_t repSpread)
{
    uint32_t regOffset;
 
    regOffset = base + (repInstance * (ADC_REPxSPREAD_STEP));
 
    //
    // Configure repeater spread.
    //
    HW_WR_REG32(regOffset + CSL_ADC_REP1SPREAD,
        ((HW_RD_REG32(regOffset + CSL_ADC_REP1SPREAD) &
        ~CSL_ADC_REP1SPREAD_SPREAD_MASK) | repSpread));
 
}
 
//
//
//*****************************************************************************
extern void
ADC_setMode(uint32_t base, ADC_Resolution resolution,
            ADC_SignalMode signalMode);
 
//*****************************************************************************
//
//
//*****************************************************************************
extern void
ADC_setPPBTripLimits(uint32_t base, ADC_PPBNumber ppbNumber,
                     int32_t tripHiLimit, int32_t tripLoLimit);
 
//*****************************************************************************
//
// Close the Doxygen group.
//
//*****************************************************************************
 
//*****************************************************************************
//
// Mark the end of the C bindings section for C++ compilers.
//
//*****************************************************************************
#ifdef __cplusplus
}
#endif
 
#endif // ADC_V1_H_