LGPTimerLPF3.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023-2024, Texas Instruments Incorporated
 * All rights reserved.
 *
 * 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.
 */
/*!*****************************************************************************
 *  @file       LGPTimerLPF3.h
 *  @brief      LGPTimer driver implementation for Low Power F3 devices
 *
 *  @anchor ti_drivers_LGPTimer_Overview
 *  # Overview #
 *  The LGPTimer driver allows you to measure elapsed time with simple and
 *  portable APIs. It also allows for asynchronous callbacks after a
 *  certain amount of time has elapsed.
 *  In addition the driver supports APIs for both capture and compare of
 *  of IO signals muxable to the three channels of each LGPT peripheral
 *  instance. The channel capture functionality can be used to measure period
 *  and duty cycle of an input signal. The channel compare functionality can
 *  be used for generating PWM signals.
 *
 *  The LGPTimer driver also handles the general purpose timer resource allocation.
 *  For each driver that requires use of a general purpose timer, it calls
 *  #LGPTimerLPF3_open() to occupy the specified timer, and calls
 *  #LGPTimerLPF3_close() to release the occupied timer resource.
 *
 *  @anchor ti_drivers_LGPTimer_PeripheralProperties
 *  # LGPT peripheral properties #
 *  The LGPT peripherals support different timer counter widths depending
 *  on the peripheral instance number (LGPT0, LGPT1, ..). The table below
 *  lists supported counter widths for each peripheral instance number on
 *  available device types.
 *  The timer counter clock is sourced from the internal prescaler stage which
 *  has the high frequency clock (CLKSVT) as input.
 *  The prescaler can be configured to divide the input system clock, effectively
 *  extending the maximal time interval for the timer counter while reducing the
 *  timer resolution.
 *
 * | Device type   | LGPT0   | LGPT1   | LGPT2   | LGPT3   |
 * |---------------|---------|---------|---------|---------|
 * | CC2340R2      | 16 bits | 16 bits |   N.A   |   N.A   |
 * | CC2340R5      | 16 bits | 16 bits | 16 bits | 24 bits |
 * | CC27XX        | 16 bits | 16 bits | 16 bits | 32 bits |
 *
 *  @anchor ti_drivers_LGPTimer_CounterModes
 *  # Counter Modes #
 *  The LGPTimer driver supports the following timer counter modes:
 *    - Oneshot mode counting upwards. When the counter reaches the target value, the
 *      timer is stopped automatically and the TGT interrupt status flag
 *      (#LGPTimerLPF3_INT_TGT) is set.
 *    - Periodic mode counting upwards. When the counter reaches target value it wraps
 *      and restarts counting from 0 again. The TGT interrupt status flag is set each
 *      time the target value is reached. The ZERO interrupt status flag
 *      (#LGPTimerLPF3_INT_ZERO) is set each time the counter restarts from 0.
 *    - Periodic mode counting upwards/downwards. When the counter reaches target value
 *      while counting upwards the TGT interrupt flag is set and it starts counting
 *      downwards to 0. When 0 is reached the ZERO interrupt status flag is set
 *      and the sequence is repeated.
 *
 *  @anchor ti_drivers_LGPTimer_UnsupportedFeatures
 *  # LGPT peripheral features not supported by the LGPTimer driver #
 *  - Channel input from the event fabric is not supported
 *  - Channel output dead band control present in LGPT1 only, is not supported
 *  - Use of channel input filter is not supported
 *  - DMA usage is not supported
 *  - ADC trigger is not supported
 *  - QDEC mode where the timer functions as a quadrature decoder is not supported
 *  - Timer synchronization is not supported
 *  - IR generation is not supported
 *  - Brushless DC motor control is not supported
 *  - Fault and Park is not supported
 *  - Prescaler counter clock sourced from events is not supported
 *
 *  @anchor ti_drivers_LGPTimer_PowerManagement
 *  # Power Management #
 *  The power management framework will try to put the device into the most
 *  power efficient mode whenever possible. Please see the technical reference
 *  manual for further details on each power mode.
 *
 *  The LGPTimer driver will set constraints on disallowed power modes when
 *  needed, removing the need for the application to handle this.
 *  The following statements are valid:
 *    - After #LGPTimerLPF3_open():
 *        The device is still allowed to enter Standby. When the device is
 *        active, the corresponding LGPT peripheral will be enabled and clocked.
 *        Note that a configured counter target and configured channels, will not
 *        be retained when going in and out of Standby.
 *        The counter target is set by the functions
 *        #LGPTimerLPF3_setInitialCounterTarget() and #LGPTimerLPF3_setNextCounterTarget().
 *    - After #LGPTimerLPF3_start():
 *        The device will only go to Idle power mode since the high frequency
 *        clock (CLKSVT) is needed for timer operation.
 *    - After #LGPTimerLPF3_stop():
 *        The device is still allowed to enter Standby. When the device is
 *        active, the corresponding LGPT peripheral will be enabled and clocked.
 *    - After #LGPTimerLPF3_close():
 *        The underlying LGPT peripheral is turned off. The device is allowed to
 *        enter Standby.
 *
 *  @anchor ti_drivers_LGPTimer_Accuracy
 *  # Accuracy #
 *  The timer clock of the LGPT peripheral is dependent on the high frequency clock (CLKSVT).
 *
 *  @anchor ti_drivers_LGPTimer_Usage
 *  # Usage #
 *
 *  This documentation provides some basic @ref ti_drivers_LGPTimer_Examples "examples"
 *  in the form of commented code fragments.
 *
 *
 *  <hr>
 *  @anchor ti_drivers_LGPTimer_Examples
 *  # Examples
 *
 *  @note
 *  <b>The following examples are intended for reference only and are not
 *  intended for application use.</b>
 *
 *  @li @ref ti_drivers_LGPTimer_Example_periodic "Periodic timer"
 *  @li @ref ti_drivers_LGPTimer_Example_output "Output signal generation"
 *
 *
 *  @anchor ti_drivers_LGPTimer_Example_periodic
 *  ## Periodic timer example##
 *  The code example below will generate an interrupt using the LGPTimer every 1 ms.
 *  Note that when a count-up counter mode is used, the number of counter ticks to
 *  reach the target value equals target value + 1.
 *
 *  @anchor ti_drivers_LGPTimer_Code
 *  @code
 *  #include <ti/drivers/timer/LGPTimerLPF3.h>
 *
 *  void timerCallback(LGPTimerLPF3_Handle lgptHandle, LGPTimerLPF3_IntMask interruptMask) {
 *      // interrupt callback code goes here. Minimize processing in interrupt.
 *  }
 *
 *  void* taskFxn(void* arg) {
 *
 *    LGPTimerLPF3_Handle lgptHandle;
 *    LGPTimerLPF3_Params params;
 *    uint32_t counterTarget;
 *
 *    // Initialize parameters and assign callback function to be used
 *    LGPTimerLPF3_Params_init(&params);
 *    params.hwiCallbackFxn = timerCallback;
 *
 *    // Open driver
 *    lgptHandle = LGPTimerLPF3_open(0, &params);
 *
 *    // Set counter target
 *    counterTarget = 48000 - 1;  // 1 ms with a system clock of 48 MHz
 *    LGPTimerLPF3_setInitialCounterTarget(lgptHandle, counterTarget, true);
 *
 *    // Enable counter target interrupt
 *    LGPTimerLPF3_enableInterrupt(lgptHandle, LGPTimerLPF3_INT_TGT);
 *
 *    // Start counter in count-up-periodic mode
 *    LGPTimerLPF3_start(lgptHandle, LGPTimerLPF3_CTL_MODE_UP_PER);
 *
 *    // Generate counter target interrupt every 1 ms forever
 *    while(1);
 *  }
 *  @endcode
 *
 *
 *  @anchor ti_drivers_LGPTimer_Example_output
 *  ## Output signal generation example##
 *  The code example below will generate an output signal of 32 kHz with a 50 % duty cycle
 *  on channel 2.
 *  With an up/down counter mode, the counter target value determines the signal period and
 *  the value must be set to half the number of the total counter ticks per signal period.
 *  With a channel action of toggle-on-compare, the channel compare value must be set to
 *  (counter target value)/2 in order to obtain a 50 % duty cycle of the output signal.
 *  The period of a 32 kHz signal equals 1500 counter ticks when the counter has a 48 MHz clock.
 *
 *
 *  @code
 *  #include <ti/drivers/timer/LGPTimerLPF3.h>
 *
 *  void* taskFxn(void* arg) {
 *
 *    LGPTimerLPF3_Handle lgptHandle;
 *    LGPTimerLPF3_Params params;
 *    uint32_t cntTargetVal = 1500/2;
 *    uint32_t chCompVal    = cntTargetVal/2;
 *
 *    // Configure channel 2 action
 *    LGPTimerLPF3_Params_init(&params);
 *    params.channelProperty[2].action = LGPTimerLPF3_CH_TOGGLE_ON_COMPARE_PERIODIC;
 *
 *    // Open driver
 *    lgptHandle = LGPTimerLPF3_open(0, &params);
 *
 *    // Set channel output signal period
 *    LGPTimerLPF3_setInitialCounterTarget(lgptHandle, cntTargetVal, false);
 *
 *    // Set channel output signal duty cycle
 *    LGPTimerLPF3_setInitialChannelCompVal(lgptHandle, LGPTimerLPF3_CH_NO_2, chCompVal, false);
 *
 *    // Start the LGPTimer in up-down-periodic mode
 *    LGPTimerLPF3_start(lgptHandle, LGPTimerLPF3_CTL_MODE_UPDWN_PER);
 *
 *    // Output signal forever
 *    while(1);
 *  }
 *  @endcode
 *
 *
 *  ## Opening the LGPTimerLPF3 Driver #
 *
 *  Opening a LGPTimerLPF3 requires four steps:
 *  1.  Create and initialize a #LGPTimerLPF3_Params structure.
 *  2.  Set non-default parameter values.
 *  3.  Call #LGPTimerLPF3_open(), passing the index of the timer in the
 *      #LGPTimerLPF3_Config structure, and the address of the #LGPTimerLPF3_Params
 *      structure. The timer instance is specified by the index in the
 *      #LGPTimerLPF3_Config structure.
 *  4.  Verify that the timer handle returned by #LGPTimerLPF3_open() is non-NULL.
 *      The handle will be used to operate the timer driver instance you just opened.
 *
 *  <hr>
 *  @anchor ti_drivers_LGPT_Configuration
 *  # Configuration
 *
 *  Refer to the @ref driver_configuration "Driver's Configuration" section
 *  for driver configuration information.
 *  <hr>
 *
 *  ============================================================================
 */

#ifndef ti_drivers_timer_LGPTimerLPF3__include
#define ti_drivers_timer_LGPTimerLPF3__include

#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>

#include <ti/drivers/dpl/HwiP.h>
#include <ti/drivers/Power.h>
#include <ti/drivers/GPIO.h>

#include <ti/devices/DeviceFamily.h>
#include DeviceFamily_constructPath(inc/hw_lgpt.h)

#ifdef __cplusplus
extern "C" {
#endif

/* Define for number of channels on the LPGPT peripheral */
#define NO_OF_LGPT_CHANNELS 3

typedef enum
{
    LGPTimerLPF3_CH_NO_0 = 0,
    LGPTimerLPF3_CH_NO_1 = 1,
    LGPTimerLPF3_CH_NO_2 = 2,
} LGPTimerLPF3_ChannelNo;

typedef enum
{
    LGPTimerLPF3_CH_DIR_NONE   = 0,
    LGPTimerLPF3_CH_DIR_INPUT  = 1,
    LGPTimerLPF3_CH_DIR_OUTPUT = 2,
} LGPTimerLPF3_ChannelDir;

typedef enum
{
    LGPTimerLPF3_CH_LEVEL_LOW  = LGPT_OUTCTL_CLROUT0,
    LGPTimerLPF3_CH_LEVEL_HIGH = LGPT_OUTCTL_SETOUT0,
} LGPTimerLPF3_ChannelLevel;

typedef enum
{
    LGPTimerLPF3_CH_EDGE_NONE = LGPT_C0CFG_EDGE_NONE,
    LGPTimerLPF3_CH_EDGE_RISE = LGPT_C0CFG_EDGE_RISE,
    LGPTimerLPF3_CH_EDGE_FALL = LGPT_C0CFG_EDGE_FALL,
    LGPTimerLPF3_CH_EDGE_BOTH = LGPT_C0CFG_EDGE_BOTH,
} LGPTimerLPF3_ChannelInputEdge;

typedef enum
{
    LGPTimerLPF3_CTL_MODE_DIS       = LGPT_CTL_MODE_DIS,
    LGPTimerLPF3_CTL_MODE_UP_ONCE   = LGPT_CTL_MODE_UP_ONCE,
    LGPTimerLPF3_CTL_MODE_UP_PER    = LGPT_CTL_MODE_UP_PER,
    LGPTimerLPF3_CTL_MODE_UPDWN_PER = LGPT_CTL_MODE_UPDWN_PER,
} LGPTimerLPF3_Mode;

typedef enum
{
    LGPTimerLPF3_INT_TGT            = 1 << LGPT_RIS_TGT_S,
    LGPTimerLPF3_INT_ZERO           = 1 << LGPT_RIS_ZERO_S,
    LGPTimerLPF3_INT_COUNTER_CHANGE = 1 << LGPT_RIS_CNTRCHNG_S,
    LGPTimerLPF3_INT_DIR_CHANGE     = 1 << LGPT_RIS_DIRCHNG_S,
    LGPTimerLPF3_INT_CH0_CC         = 1 << LGPT_RIS_C0CC_S,
    LGPTimerLPF3_INT_CH1_CC         = 1 << LGPT_RIS_C1CC_S,
    LGPTimerLPF3_INT_CH2_CC         = 1 << LGPT_RIS_C2CC_S,
} LGPTimerLPF3_Interrupt;

typedef enum
{
    LGPTimerLPF3_DEBUG_STALL_OFF       = LGPT_EMU_HALT_DIS,
    LGPTimerLPF3_DEBUG_STALL_IMMEDIATE = (LGPT_EMU_HALT_EN | LGPT_EMU_CTL_IMMEDIATE),
    LGPTimerLPF3_DEBUG_STALL_ON_ZERO   = (LGPT_EMU_HALT_EN | LGPT_EMU_CTL_ZERCOND),
} LGPTimerLPF3_DebugMode;

typedef enum
{
    LGPTimerLPF3_CH_COMPARE_COUNTER_DIR_BOTH = LGPT_CTL_CMPDIR_BOTH,
    LGPTimerLPF3_CH_COMPARE_COUNTER_DIR_UP   = LGPT_CTL_CMPDIR_UP,
    LGPTimerLPF3_CH_COMPARE_COUNTER_DIR_DOWN = LGPT_CTL_CMPDIR_DOWN,
} LGPTimerLPF3_ChannelCmpDir;

typedef enum
{
    LGPTimerLPF3_CH_DISABLE = LGPT_C1CFG_CCACT_DIS,

    /*************************************************************************************
     *                        Channel compare actions.                                   *
     *                                                                                   *
     * The following list of channel compare actions will force the channel to be        *
     * configured as an output.                                                          *
     ************************************************************************************/
    LGPTimerLPF3_CH_TOGGLE_ON_COMPARE_PERIODIC = LGPT_C0CFG_CCACT_TGL_ON_CMP,

    LGPTimerLPF3_CH_TOGGLE_ON_COMPARE_ONCE = LGPT_C0CFG_CCACT_TGL_ON_CMP_DIS,

    LGPTimerLPF3_CH_SET_ON_COMPARE_PERIODIC = LGPT_C0CFG_CCACT_SET_ON_CMP,

    LGPTimerLPF3_CH_SET_ON_COMPARE_ONCE = LGPT_C0CFG_CCACT_SET_ON_CMP_DIS,

    LGPTimerLPF3_CH_CLEAR_ON_COMPARE_PERIODIC = LGPT_C0CFG_CCACT_CLR_ON_CMP,

    LGPTimerLPF3_CH_CLEAR_ON_COMPARE_ONCE = LGPT_C0CFG_CCACT_CLR_ON_CMP_DIS,

    LGPTimerLPF3_CH_SET_ON_0_TOGGLE_ON_CMP_PERIODIC = LGPT_C0CFG_CCACT_SET_ON_0_TGL_ON_CMP,

    LGPTimerLPF3_CH_SET_ON_0_TOGGLE_ON_COMPARE_ONCE = LGPT_C0CFG_CCACT_SET_ON_0_TGL_ON_CMP_DIS,

    LGPTimerLPF3_CH_CLR_ON_0_TOGGLE_ON_COMPARE_PERIODIC = LGPT_C0CFG_CCACT_CLR_ON_0_TGL_ON_CMP,

    LGPTimerLPF3_CH_CLR_ON_0_TOGGLE_ON_COMPARE_ONCE = LGPT_C0CFG_CCACT_CLR_ON_0_TGL_ON_CMP_DIS,

    LGPTimerLPF3_CH_PULSE_ON_COMPARE_PERIODIC = LGPT_C0CFG_CCACT_PULSE_ON_CMP,

    LGPTimerLPF3_CH_PULSE_ON_COMPARE_ONCE = LGPT_C0CFG_CCACT_PULSE_ON_CMP_DIS,

    /*************************************************************************************
     *                     Channel capture actions.                                      *
     *                                                                                   *
     * The following list of channel actions will force the channel to be configured as  *
     * an input.                                                                         *
     * The counter value will be captured and the captured value can be read by the      *
     * #LGPTimerLPF3_getChCompareVal() and #LGPTimerLPF3_getNextChCompareVal()           *
     * functions.                                                                        *
     ************************************************************************************/
    LGPTimerLPF3_CH_SET_ON_CAPTURE_PERIODIC = LGPT_C0CFG_CCACT_SET_ON_CAPT,

    LGPTimerLPF3_CH_SET_ON_CAPTURE_ONCE = LGPT_C0CFG_CCACT_SET_ON_CAPT_DIS,

    LGPTimerLPF3_CH_PULSE_WIDTH_MEASURE = LGPT_C0CFG_CCACT_PER_PULSE_WIDTH_MEAS,
} LGPTimerLPF3_ChannelAction;

/* Forward declaration of LGPTimer configuration */
typedef struct LGPTimerLPF3_Config LGPTimerLPF3_Config;

/* LGPTimer handle is pointer to configuration structure */
typedef LGPTimerLPF3_Config *LGPTimerLPF3_Handle;

/* Interrupt bit vector. See LGPTimerLPF3_Interrupt for available interrupts */
typedef uint16_t LGPTimerLPF3_IntMask;

typedef void (*LGPTimerLPF3_HwiFxn)(LGPTimerLPF3_Handle handle, LGPTimerLPF3_IntMask interruptMask);

typedef struct LGPTimerLPF3_ChannelProp
{
    LGPTimerLPF3_ChannelAction action;
    LGPTimerLPF3_ChannelInputEdge inputEdge;
} LGPTimerLPF3_ChannelProp;

typedef struct LGPTimerLPF3_Params
{
    LGPTimerLPF3_HwiFxn hwiCallbackFxn;
    bool intPhaseLate;
    uint8_t prescalerDiv;
    LGPTimerLPF3_DebugMode debugStallMode;
    LGPTimerLPF3_ChannelCmpDir counterDirChCompare;
    LGPTimerLPF3_ChannelProp channelProperty[NO_OF_LGPT_CHANNELS];
} LGPTimerLPF3_Params;

typedef struct LGPTimerLPF3_ChannelConf
{
    uint8_t pin;
    uint8_t pinMux;
    uint8_t nPin;
    uint8_t nPinMux;
} LGPTimerLPF3_ChannelConf;

typedef struct LGPTimerLPF3_HWAttrs
{
    uint32_t baseAddr;
    PowerLPF3_Resource powerID;
    LGPTimerLPF3_ChannelConf channelConfig[NO_OF_LGPT_CHANNELS];
    uint8_t intNum;
    uint8_t intPriority;
} LGPTimerLPF3_HWAttrs;

typedef struct LGPTimerLPF3_Object
{
    HwiP_Struct hwi;                                
    LGPTimerLPF3_HwiFxn hwiCallbackFxn;             
    Power_NotifyObj postNotify;                     
    uint32_t arg;                                   
    bool isOpen;                                    
    bool intPhaseLate;                              
    uint8_t prescalerDiv;                           
    LGPTimerLPF3_DebugMode debugStallMode;          
    LGPTimerLPF3_ChannelCmpDir counterDirChCompare; 
    LGPTimerLPF3_ChannelProp channelProperty[NO_OF_LGPT_CHANNELS]; 
} LGPTimerLPF3_Object;

struct LGPTimerLPF3_Config
{
    LGPTimerLPF3_Object *object;
    const LGPTimerLPF3_HWAttrs *hwAttrs;
};

extern void LGPTimerLPF3_Params_init(LGPTimerLPF3_Params *params);

extern LGPTimerLPF3_Handle LGPTimerLPF3_open(uint_least8_t index, const LGPTimerLPF3_Params *params);

extern void LGPTimerLPF3_close(LGPTimerLPF3_Handle handle);

extern void LGPTimerLPF3_start(LGPTimerLPF3_Handle handle, LGPTimerLPF3_Mode mode);

extern void LGPTimerLPF3_stop(LGPTimerLPF3_Handle handle);

extern void LGPTimerLPF3_setInitialCounterTarget(LGPTimerLPF3_Handle handle, uint32_t value, bool intFlagClr);

extern void LGPTimerLPF3_setNextCounterTarget(LGPTimerLPF3_Handle handle, uint32_t value, bool intFlagClr);

extern uint32_t LGPTimerLPF3_getCounter(LGPTimerLPF3_Handle handle);

extern uint32_t LGPTimerLPF3_getArg(LGPTimerLPF3_Handle handle);

extern void LGPTimerLPF3_setArg(LGPTimerLPF3_Handle handle, void *arg);

void LGPTimerLPF3_enableInterrupt(LGPTimerLPF3_Handle handle, LGPTimerLPF3_IntMask intMask);

void LGPTimerLPF3_disableInterrupt(LGPTimerLPF3_Handle handle, LGPTimerLPF3_IntMask intMask);

void LGPTimerLPF3_setInitialChannelCompVal(LGPTimerLPF3_Handle handle,
                                           LGPTimerLPF3_ChannelNo chNo,
                                           uint32_t value,
                                           bool intFlagClr);

void LGPTimerLPF3_setNextChannelCompVal(LGPTimerLPF3_Handle handle,
                                        LGPTimerLPF3_ChannelNo chNo,
                                        uint32_t value,
                                        bool intFlagClr);

void LGPTimerLPF3_setChannelOutputLevel(LGPTimerLPF3_Handle handle,
                                        LGPTimerLPF3_ChannelNo chNo,
                                        LGPTimerLPF3_ChannelLevel level);

uint32_t LGPTimerLPF3_getChCompareVal(LGPTimerLPF3_Handle handle, LGPTimerLPF3_ChannelNo chNo);

uint32_t LGPTimerLPF3_getChCaptureVal(LGPTimerLPF3_Handle handle, LGPTimerLPF3_ChannelNo chNo);

uint32_t LGPTimerLPF3_getNextChCompareVal(LGPTimerLPF3_Handle handle, LGPTimerLPF3_ChannelNo chNo);

uint32_t LGPTimerLPF3_getNextChCaptureVal(LGPTimerLPF3_Handle handle, LGPTimerLPF3_ChannelNo chNo);

uint32_t LGPTimerLPF3_getCounterWidth(LGPTimerLPF3_Handle handle);

#ifdef __cplusplus
}
#endif
#endif /* ti_drivers_timer_LGPTimerLPF3__include */