/*==================================================================================================
* Project : RTD AUTOSAR 4.4
* Platform : CORTEXM
* Peripheral : Ftm_Srtc_Lptmr_LPit
* Dependencies : none
*
* Autosar Version : 4.4.0
* Autosar Revision : ASR_REL_4_4_REV_0000
* Autosar Conf.Variant :
* SW Version : 1.0.0
* Build Version : S32K1_RTD_1_0_0_HF01_D2109_ASR_REL_4_4_REV_0000_20210907
*
* (c) Copyright 2020-2021 NXP Semiconductors
* All Rights Reserved.
*
* NXP Confidential. This software is owned or controlled by NXP and may only be
* used strictly in accordance with the applicable license terms. By expressly
* accepting such terms or by downloading, installing, activating and/or otherwise
* using the software, you are agreeing that you have read, and that you agree to
* comply with and are bound by, such license terms. If you do not agree to be
* bound by the applicable license terms, then you may not retain, install,
* activate or otherwise use the software.
==================================================================================================*/
#ifndef GPT_H
#define GPT_H
/**
* @file Gpt.h
*
* @addtogroup gpt Gpt Driver
* @{
*/
#ifdef __cplusplus
extern "C"{
#endif
/*==================================================================================================
* INCLUDE FILES
* 1) system and project includes
* 2) needed interfaces from external units
* 3) internal and external interfaces from this unit
==================================================================================================*/
#include "StandardTypes.h"
#include "Gpt_Ipw_Types.h"
#include "Gpt_Cfg.h"
#include "Gpt_EnvCfg.h"
#include "Mcal.h"
#if (GPT_WAKEUP_FUNCTIONALITY_API == STD_ON)
#include "EcuM_Externals.h"
#endif
/*==================================================================================================
* SOURCE FILE VERSION INFORMATION
==================================================================================================*/
/**
* @internal
* @brief Defines used for file version checks
*/
#define GPT_VENDOR_ID 43
#define GPT_MODULE_ID 100
#define GPT_AR_RELEASE_MAJOR_VERSION 4
#define GPT_AR_RELEASE_MINOR_VERSION 4
#define GPT_AR_RELEASE_REVISION_VERSION 0
#define GPT_SW_MAJOR_VERSION 1
#define GPT_SW_MINOR_VERSION 0
#define GPT_SW_PATCH_VERSION 0
/*==================================================================================================
* FILE VERSION CHECKS
==================================================================================================*/
/* Check if header file and Std_Types.h file are of the same Autosar version */
#ifndef DISABLE_MCAL_INTERMODULE_ASR_CHECK
#if ((GPT_AR_RELEASE_MAJOR_VERSION != STD_AR_RELEASE_MAJOR_VERSION) || \
(GPT_AR_RELEASE_MINOR_VERSION != STD_AR_RELEASE_MINOR_VERSION))
#error "AutoSar Version Numbers of Gpt.h and Std_Types.h are different"
#endif
/* Check if Gpt.h file and Mcal.h header file are of the same Autosar version */
#if ((GPT_AR_RELEASE_MAJOR_VERSION != MCAL_AR_RELEASE_MAJOR_VERSION) || \
(GPT_AR_RELEASE_MINOR_VERSION != MCAL_AR_RELEASE_MINOR_VERSION))
#error "AutoSar Version Numbers of Gpt.h and Mcal.h are different"
#endif
#endif
/* Check if header file and EcuM_Cbk.h file are of the same Autosar version */
#ifndef DISABLE_MCAL_INTERMODULE_ASR_CHECK
#if (GPT_WAKEUP_FUNCTIONALITY_API == STD_ON)
#if ((GPT_AR_RELEASE_MAJOR_VERSION != ECUM_CBK_AR_RELEASE_MAJOR_VERSION) || \
(GPT_AR_RELEASE_MINOR_VERSION != ECUM_CBK_AR_RELEASE_MINOR_VERSION) \
)
#error "AutoSar Version Numbers of Gpt.h and EcuM_Externals.h are different"
#endif
#endif
#endif
#if (GPT_VENDOR_ID != GPT_IPW_TYPES_VENDOR_ID)
#error "Gpt.h and Gpt_Ipw_Types.h have different vendor ids"
#endif
/* Check if this header file and GPT IPW header file are of the same Autosar version */
#if ((GPT_AR_RELEASE_MAJOR_VERSION != GPT_IPW_TYPES_AR_RELEASE_MAJOR_VERSION) || \
(GPT_AR_RELEASE_MINOR_VERSION != GPT_IPW_TYPES_AR_RELEASE_MINOR_VERSION) || \
(GPT_AR_RELEASE_REVISION_VERSION != GPT_IPW_TYPES_AR_RELEASE_REVISION_VERSION) \
)
#error "AutoSar Version Numbers of Gpt.h and Gpt_Ipw_Types.h are different"
#endif
/* Check if this header file and GPT IPW header file are of the same Software version */
#if ((GPT_SW_MAJOR_VERSION != GPT_IPW_TYPES_SW_MAJOR_VERSION) || \
(GPT_SW_MINOR_VERSION != GPT_IPW_TYPES_SW_MINOR_VERSION) || \
(GPT_SW_PATCH_VERSION != GPT_IPW_TYPES_SW_PATCH_VERSION) \
)
#error "Software Version Numbers of Gpt.h and Gpt_Ipw_Types.h are different"
#endif
#if ( GPT_VENDOR_ID!= GPT_ENVCFG_VENDOR_ID)
#error "Gpt.h and Gpt_EnvCfg.h have different vendor ids"
#endif
/* Check if the header files are of the same Autosar version */
#if ((GPT_AR_RELEASE_MAJOR_VERSION != GPT_ENVCFG_AR_RELEASE_MAJOR_VERSION) || \
(GPT_AR_RELEASE_MINOR_VERSION != GPT_ENVCFG_AR_RELEASE_MINOR_VERSION) || \
(GPT_AR_RELEASE_REVISION_VERSION != GPT_ENVCFG_AR_RELEASE_REVISION_VERSION) \
)
#error "AutoSar Version Numbers of Gpt.h and Gpt_EnvCfg.h are different"
#endif
/* Check if the header files are of the same Software version */
#if ((GPT_SW_MAJOR_VERSION != GPT_ENVCFG_SW_MAJOR_VERSION) || \
(GPT_SW_MINOR_VERSION != GPT_ENVCFG_SW_MINOR_VERSION) || \
(GPT_SW_PATCH_VERSION != GPT_ENVCFG_SW_PATCH_VERSION) \
)
#error "Software Version Numbers of Gpt.h and Gpt_EnvCfg.h are different"
#endif
#if ( GPT_VENDOR_ID!= GPT_VENDOR_ID_CFG)
#error "Gpt.h and Gpt_Cfg.h have different vendor ids"
#endif
/* Check if the header files are of the same Autosar version */
#if ((GPT_AR_RELEASE_MAJOR_VERSION != GPT_AR_RELEASE_MAJOR_VERSION_CFG) || \
(GPT_AR_RELEASE_MINOR_VERSION != GPT_AR_RELEASE_MINOR_VERSION_CFG) || \
(GPT_AR_RELEASE_REVISION_VERSION != GPT_AR_RELEASE_REVISION_VERSION_CFG) \
)
#error "AutoSar Version Numbers of Gpt.h and Gpt_Cfg.h are different"
#endif
/* Check if the header files are of the same Software version */
#if ((GPT_SW_MAJOR_VERSION != GPT_SW_MAJOR_VERSION_CFG) || \
(GPT_SW_MINOR_VERSION != GPT_SW_MINOR_VERSION_CFG) || \
(GPT_SW_PATCH_VERSION != GPT_SW_PATCH_VERSION_CFG) \
)
#error "Software Version Numbers of Gpt.h and Gpt_Cfg.h are different"
#endif
/*==================================================================================================
* CONSTANT-LIKE DEFINES
==================================================================================================*/
/*==================================================================================================
* FUNCTION-LIKE DEFINES(MACROS)
==================================================================================================*/
/*==================================================================================================*/
/**
* @brief Function Gpt_StartTimer is called when the driver is in sleep mode for a channel which is not wakeup enabled.
* @details Errors and exceptions that will be detected by the GPT driver.
*
* @implements Gpt_Det_ErrorCodes_define
*/
#if(GPT_VALIDATE_STATE == STD_ON)
#if(((GPT_WAKEUP_FUNCTIONALITY_API == STD_ON) && (GPT_REPORT_WAKEUP_SOURCE == STD_ON)) || (GPT_CHANGE_NEXT_TIMEOUT_VALUE == STD_ON))
#define GPT_E_INVALID_CALL ((uint8)0xA0U)
#endif
#endif
/**
* @brief Function called without module initialization.
* @details Errors and exceptions that will be detected by the GPT driver.
*
* @implements Gpt_Det_ErrorCodes_define
*/
#if((GPT_VALIDATE_CHANNEL_CALL == STD_ON) || (GPT_VALIDATE_GLOBAL_CALL == STD_ON))
#define GPT_E_UNINIT ((uint8)0x0AU)
#endif
/**
* @brief Initialization called when already initialized.
* @details Errors and exceptions that will be detected by the GPT driver.
*
* @implements Gpt_Det_ErrorCodes_define
*/
#if(GPT_VALIDATE_GLOBAL_CALL == STD_ON)
#define GPT_E_ALREADY_INITIALIZED ((uint8)0x0DU)
#endif
/**
* @brief Function called for invalid channel.
* @details Errors and exceptions that will be detected by the GPT driver.
*
* @implements Gpt_Det_ErrorCodes_define
*/
#define GPT_E_PARAM_CHANNEL ((uint8)0x14U)
/**
* @brief Function called with parameter value out of range
* @details Errors and exceptions that will be detected by the GPT driver
*
* @implements Gpt_Det_ErrorCodes_define
*/
#if (GPT_VALIDATE_PARAM == STD_ON)
#define GPT_E_PARAM_VALUE ((uint8)0x15U)
#endif
#if(((GPT_PREDEFTIMER_FUNCTIONALITY_API == STD_ON) && (GPT_VALIDATE_PARAM == STD_ON)) ||\
((GPT_VERSION_INFO_API == STD_ON) && (GPT_DEV_ERROR_DETECT == STD_ON)))
/**
* @brief Function called with NULL pointer
* @details Errors and exceptions that will be detected by the GPT driver
*
* @implements Gpt_Det_ErrorCodes_define
*/
#define GPT_E_PARAM_POINTER ((uint8)0x16U)
#endif
#if((GPT_PREDEFTIMER_FUNCTIONALITY_API == STD_ON) && (GPT_VALIDATE_PARAM == STD_ON))
/**
* @brief Function called with invalid the parameter in function Gpt_GetPredefTimerValue
* @details Errors and exceptions that will be detected by the GPT driver
*
* @implements Gpt_Det_ErrorCodes_define
*/
#define GPT_E_PARAM_PREDEF_TIMER ((uint8)0x17)
#endif /* (GPT_PREDEFTIMER_FUNCTIONALITY_API == STD_ON) && (GPT_VALIDATE_PARAM == STD_ON) */
/**
* @brief Function called when timer channel is still running.
* @details Errors and exceptions that will be detected by the GPT driver.
*
* @implements Gpt_Det_ErrorCodes_define
*/
#define GPT_E_BUSY ((uint8)0x0BU)
#if(GPT_PREDEFTIMER_FUNCTIONALITY_API == STD_ON)
/**
* @brief Function called with invalid the parameter in function Gpt_GetPredefTimerValue
* @details Errors and exceptions that will be detected by the GPT driver
*
* @implements Gpt_Det_ErrorCodes_define
*/
#define GPT_E_MODE ((uint8)0x0C)
#endif /* (GPT_PREDEFTIMER_FUNCTIONALITY_API == STD_ON) */
/**
* @brief Function called when a timeout is occurred.
* @details Errors and exceptions that will be detected by the GPT driver.
*
* @implements Gpt_Det_ErrorCodes_define
*/
#define GPT_E_TIMEOUT ((uint8)0x2BU)
/**
* @brief Function called with invalid the parameter in function Gpt_Init
* @details Errors and exceptions that will be detected by the GPT driver
*
* @implements Gpt_Det_ErrorCodes_define
*/
#if((GPT_VALIDATE_PARAM == STD_ON) && (GPT_DEV_ERROR_DETECT == STD_ON))
#define GPT_E_INIT_FAILED ((uint8)0x0E)
#endif
/**
* @brief API Gpt_SetClockMode service called with wrong parameter.
* @details Parameters used when raising an error/exception
* @implements
*/
#if((GPT_SET_CLOCK_MODE == STD_ON) && (GPT_VALIDATE_PARAM == STD_ON))
#define GPT_E_PARAM_CLOCK_MODE ((uint8)0x17U)
#endif
/**
* @brief Function called with invalid mode param.
* @details Errors and exceptions that will be detected by the GPT driver
*
* @implements Gpt_Det_ErrorCodes_define
*/
#if ((GPT_VALIDATE_PARAM == STD_ON) &&(GPT_WAKEUP_FUNCTIONALITY_API == STD_ON) && (GPT_REPORT_WAKEUP_SOURCE == STD_ON))
#define GPT_E_PARAM_MODE ((uint8)0x1FU)
#endif
/**
* @brief function called for invalid channel on the current core
* @details Errors and exceptions that will be detected by the GPT driver
*
* @implements Gpt_Det_ErrorCodes_define
*/
#define GPT_E_PARAM_CONFIG ((uint8)0x18U)
/** API SERVICE IDs */
/**
* @brief API service ID for Gpt_GetVersionInfo function
* @details Parameters used when raising an error/exception
*/
#if ((GPT_VERSION_INFO_API == STD_ON) && (GPT_DEV_ERROR_DETECT == STD_ON))
#define GPT_GETVERSIONINFO_ID ((uint8)0x00U)
#endif
/**
* @brief API service ID for Gpt_Init function
* @details Parameters used when raising an error/exception
*/
#if ((GPT_VALIDATE_GLOBAL_CALL == STD_ON) || ((GPT_VALIDATE_PARAM == STD_ON) && (GPT_DEV_ERROR_DETECT == STD_ON)))
#define GPT_INIT_ID ((uint8)0x01U)
#endif
/**
* @brief API service ID for Gpt_DeInit function
* @details Parameters used when raising an error/exception
*/
#if (GPT_DEINIT_API == STD_ON)
#define GPT_DEINIT_ID ((uint8)0x02U)
#endif
/**
* @brief API service ID for Gpt_GetTimeElapsed function
* @details Parameters used when raising an error/exception
*/
#if ((GPT_TIME_ELAPSED_API == STD_ON) && (GPT_VALIDATE_CHANNEL_CALL == STD_ON))
#define GPT_TIMEELAPSED_ID ((uint8)0x03U)
#endif
/**
* @brief API service ID for Gpt_GetTimeRemaining function
* @details Parameters used when raising an error/exception
*/
#if ((GPT_TIME_REMAINING_API == STD_ON) && (GPT_VALIDATE_CHANNEL_CALL == STD_ON))
#define GPT_TIMEREMAINING_ID ((uint8)0x04U)
#endif
/**
* @brief API service ID for Gpt_StartTimer function
* @details Parameters used when raising an error/exception
*/
#define GPT_STARTTIMER_ID ((uint8)0x05U)
/**
* @brief API service ID for Gpt_StopTimer function
* @details Parameters used when raising an error/exception
*/
#if(GPT_VALIDATE_CHANNEL_CALL == STD_ON)
#define GPT_STOPTIMER_ID ((uint8)0x06U)
#endif
#if((GPT_ENABLE_DISABLE_NOTIFICATION_API == STD_ON) && ((GPT_VALIDATE_CHANNEL_CALL == STD_ON) || (GPT_VALIDATE_PARAM == STD_ON)))
/**
* @brief API service ID for Gpt_EnableNotification function
* @details Parameters used when raising an error/exception
*/
#define GPT_ENABLENOTIFICATION_ID ((uint8)0x07U)
/**
* @brief API service ID for Gpt_DisableNotification function
* @details Parameters used when raising an error/exception
*/
#define GPT_DISABLENOTIFICATION_ID ((uint8)0x08U)
#endif
/**
* @brief API service ID for Gpt_SetMode function
* @details Parameters used when raising an error/exception
*/
#if(((GPT_WAKEUP_FUNCTIONALITY_API == STD_ON) && (GPT_VALIDATE_GLOBAL_CALL == STD_ON)) ||\
((GPT_VALIDATE_PARAM == STD_ON) &&(GPT_WAKEUP_FUNCTIONALITY_API == STD_ON) && (GPT_REPORT_WAKEUP_SOURCE == STD_ON)))
#define GPT_SETMODE_ID ((uint8)0x09U)
#endif
#if ((GPT_WAKEUP_FUNCTIONALITY_API == STD_ON) && (GPT_REPORT_WAKEUP_SOURCE == STD_ON))
#if((GPT_VALIDATE_CHANNEL_CALL == STD_ON) || (GPT_VALIDATE_PARAM == STD_ON))
/**
* @brief API service ID for Gpt_DisableWakeup function
* @details Parameters used when raising an error/exception
*/
#define GPT_DISABLEWAKEUP_ID ((uint8)0x0AU)
/**
* @brief API service ID for Gpt_EnableWakeup function
* @details Parameters used when raising an error/exception
*/
#define GPT_ENABLEWAKEUP_ID ((uint8)0x0BU)
#endif
/**
* @brief API service ID for Gpt_CheckWakeup function
* @details Parameters used when raising an error/exception
*/
#if (GPT_VALIDATE_GLOBAL_CALL == STD_ON)
#define GPT_CHECKWAKEUP_ID ((uint8)0x0CU)
#endif
#endif /* ((GPT_WAKEUP_FUNCTIONALITY_API == STD_ON) && (GPT_REPORT_WAKEUP_SOURCE == STD_ON)) */
/**
* @brief API service ID for Gpt_ProcessCommonInterrupt generic ISR handler
* @details Parameters used when raising an error/exception
*/
#define GPT_PROCESSCOMMONINTERRUPT_ID ((uint8)0x11U)
/**
* @brief API service ID for Gpt_ChangeNextTimeoutValue function
* @details Parameters used when raising an error/exception
*/
#if (GPT_CHANGE_NEXT_TIMEOUT_VALUE == STD_ON)
#define GPT_CHANGE_NEXT_TIMEOUT_VALUE_ID ((uint8)0x0FU)
#endif
/**
* @brief API service ID for Gpt_SetClockMode function
* @details Parameters used when raising an error/exception
*/
#if((GPT_VALIDATE_GLOBAL_CALL == STD_ON) && (GPT_SET_CLOCK_MODE == STD_ON))
#define GPT_SET_CLOCK_MODE_ID ((uint8)0x10U)
#endif
/**
* @brief API service ID for Gpt_GetPredefTimerValue function
* @details Parameters used when raising an error/exception
*/
#if(GPT_PREDEFTIMER_FUNCTIONALITY_API == STD_ON)
#define GPT_GET_PREDEF_TIMERVALUE_ID ((uint8)0x0DU)
#endif
/**
* @brief API service ID for Gpt_Channel_EnableChainMode function
* @details Parameters used when raising an error/exception
*/
#if(GPT_CHAIN_MODE == STD_ON)
#define GPT_ENABLE_CHAIN_MODE_ID ((uint8)0x21U)
#define GPT_DISABLE_CHAIN_MODE_ID ((uint8)0x22U)
#endif
/**
* @brief Instance ID of this GPT driver.
*
*/
#define GPT_INSTANCE_ID ((uint8)0U)
/*==================================================================================================
* ENUMS
==================================================================================================*/
/**
* @brief This enumerated type allows the selection of different power modes.
* @details Modes of the GPT driver.
*
* @implements Gpt_ModeType_enumeration
*/
typedef enum
{
GPT_MODE_NORMAL = 0U, /**< @brief GPT Normal operation mode of the GPT */
GPT_MODE_SLEEP = 1U /**< @brief GPT Sleep mode */
} Gpt_ModeType;
/**
* @brief Gpt channel mode type. Indicates of whether the channel mode is "CONTINUOUS" or "ONE SHOT".
* @details ChannelModeType of channel.
*/
typedef enum
{
GPT_CH_MODE_CONTINUOUS = 0U, /**< @brief GPT channel mode - continuous mode */
GPT_CH_MODE_ONESHOT = 1U /**< @brief GPT channel mode - one-shot mode. */
} Gpt_ChannelModeType;
/**
* @brief Prescaler type. Indicates of whether the clock channel mode is "GPT_NORMAL" or "GPT_ALTERNATE".
* @details This enumeration specifies the possible types of prescalers used to configure base-clock timers
*/
#if (GPT_SET_CLOCK_MODE == STD_ON)
typedef enum
{
GPT_CLOCKMODE_NORMAL = 0x0U, /**< @brief Selected value is the NORMAL configured prescaler */
GPT_CLOCKMODE_ALTERNATE = 0x1U /**< @brief Selected value is the ALTERNATE configured prescaler */
} Gpt_ClockModeType;
#endif /* GPT_SET_CLOCK_MODE */
/*==================================================================================================
* STRUCTURES AND OTHER TYPEDEFS
==================================================================================================*/
/**
* @internal
* @brief Gpt channel ID data type
* @details Gpt channel type
* @implements Gpt_ChannelType_typedef
*/
typedef uint8 Gpt_ChannelType;
/**
* @internal
* @brief Used for reading and setting the timer value in number of ticks.
* @details Gpt timeout value type
* @implements Gpt_ValueType_typedef
*/
typedef uint32 Gpt_ValueType;
/**
* @internal
* @brief The callback notifications shall be configurable as pointers to
* user defined functions within the configuration structure.
* @details Gpt channel notification type.
*
*/
typedef void (*Gpt_NotificationType)(void);
/**
* @internal
* @brief Gpt channel configuration type.
* @details Configuration structure
*
*/
typedef struct
{
/** @brief GPT ch WakeUp enable */
boolean Gpt_bEnableWakeup;
/** @brief Pointer to external callback */
Gpt_NotificationType Gpt_pfNotification;
#if ((GPT_WAKEUP_FUNCTIONALITY_API == STD_ON) && (GPT_REPORT_WAKEUP_SOURCE == STD_ON))
/** @brief EcuM wake up source Id */
EcuM_WakeupSourceType Gpt_uWakeupSource;
#endif
/** @brief Channel max tick value */
Gpt_ValueType Gpt_uChannelTickValueMax;
/** @brief GPT channel mode */
Gpt_ChannelModeType Gpt_eChannelMode;
/** @brief Hardware dependent channel configuration */
Gpt_Ipw_HwChannelConfigType *Gpt_Ipw_HwChannelConfig;
} Gpt_ChannelConfigType;
/**
* @internal
* @brief Gpt configuration type.
* @details This is the type of the data structure including the configuration
* set required for initializing the GPT driver.
*
* @implements Gpt_ConfigType_structure
*/
typedef struct
{
/** @brief Number of GPT channels (configured in tresos plugin builder) */
Gpt_ChannelType channelCount;
/** @brief Pointer to the GPT channel configuration */
const Gpt_ChannelConfigType (*Gpt_pChannelConfig)[];
/** @brief Number of GPT instances (configured in tresos plugin builder) */
uint8 instanceCount;
/** @brief Pointer to the GPT instance configuration */
Gpt_Ipw_HwInstanceConfigType (*Gpt_Ipw_HwInstanceConfig)[];
#if(GPT_PREDEFTIMER_FUNCTIONALITY_API == STD_ON)
/** @brief Pointer to the GPT channel predef timer configuration */
const Gpt_HwPredefChannelConfigType * const (*Gpt_pChannelPredefConfigType);
#endif
/** @brief channel index in each partition map table*/
const uint8 (*u8GptChannelIdToIndexMap)[];
} Gpt_ConfigType;
/*==================================================================================================
* GLOBAL VARIABLE DECLARATIONS
==================================================================================================*/
#if (GPT_PRECOMPILE_SUPPORT == STD_OFF)
/**
* @internal
* @brief MemMap section
*/
#define GPT_START_SEC_CONFIG_DATA_UNSPECIFIED
#include "Gpt_MemMap.h"
#ifndef DISABLE_MCAL_INTERMODULE_ASR_CHECK
/* Check if header file and MemMap.h file are of the same Autosar version */
#if ((GPT_AR_RELEASE_MAJOR_VERSION != GPT_MEMMAP_AR_RELEASE_MAJOR_VERSION) || \
(GPT_AR_RELEASE_MINOR_VERSION != GPT_MEMMAP_AR_RELEASE_MINOR_VERSION))
#error "AutoSar Version Numbers of Gpt.h and Gpt_MemMap.h are different"
#endif
#endif
GPT_CONFIG_EXT
/**
* @internal
* @brief MemMap section
*/
#define GPT_STOP_SEC_CONFIG_DATA_UNSPECIFIED
#include "Gpt_MemMap.h"
#else
/**
* @internal
* @brief MemMap section
*/
#define GPT_START_SEC_CONFIG_DATA_UNSPECIFIED
#include "Gpt_MemMap.h"
#ifndef DISABLE_MCAL_INTERMODULE_ASR_CHECK
/* Check if header file and MemMap.h file are of the same Autosar version */
#if ((GPT_AR_RELEASE_MAJOR_VERSION != GPT_MEMMAP_AR_RELEASE_MAJOR_VERSION) || \
(GPT_AR_RELEASE_MINOR_VERSION != GPT_MEMMAP_AR_RELEASE_MINOR_VERSION))
#error "AutoSar Version Numbers of Gpt.h and Gpt_MemMap.h are different"
#endif
#endif
/* Extern declarations of GPT Pre compile configuration from Gpt_PBCfg.c */
#if (GPT_PRECOMPILE_SUPPORT == STD_ON)
#if(GPT_MULTICORE_ENABLED == STD_ON)
extern const Gpt_ConfigType* const Gpt_Config[GPT_MAX_PARTITIONS];
#else
extern const Gpt_ConfigType Gpt_Config;
#endif
#endif
/**
* @internal
* @brief MemMap section
*/
#define GPT_STOP_SEC_CONFIG_DATA_UNSPECIFIED
#include "Gpt_MemMap.h"
#endif
/*==================================================================================================
* FUNCTION PROTOTYPES
==================================================================================================*/
/**
* @internal
* @brief MemMap section
*/
#define GPT_START_SEC_CODE
#include "Gpt_MemMap.h"
/*================================================================================================*/
#if (GPT_VERSION_INFO_API == STD_ON)
/**
* @brief This function returns the version information of this module.
* @details This service returns the version information of this module. The version information
* includes:
* - Module Id
* - Vendor Id
* - Vendor specific version numbers
* If source code for caller and callee of this function is available this function should
* be realized as a macro. The macro should be defined in the modules header file.
* @param[out] versioninfo - pointer to location to store version info
*
* @return void
* @api
*
* @pre Gpt_Init must be called before.
* @implements Gpt_GetVersionInfo_Activity
*/
void Gpt_GetVersionInfo(Std_VersionInfoType * VersionInfoPtr);
#endif
/*================================================================================================*/
/**
* @brief GPT driver initialization function.
* @details This service is a non reentrant function used for driver initialization.
* The Initialization function shall initialize all relevant registers of
* the configured hardware with the values of the structure referenced by the parameter ConfigPtr.
* All time units used within the API services of the GPT driver shall be of the unit ticks.
* This function shall only initialize the configured resources. Resources that are
* not configured in the configuration file shall not be touched.
* The following rules regarding initialization of controller registers shall apply
* to the GPT Driver implementation:
* [1] If the hardware allows for only one usage of the register, the driver
* module implementing that functionality is responsible for initializing the register
* [2] If the register can affect several hardware modules and if it is an IO register it
* shall be initialized by the PORT driver
* [3] If the register can affect several hardware modules and if it is not an IO register
* it shall be initialized by the MCU driver
* [4] One-time writable registers that require initialization directly after reset shall be
* initialized by the startup code
* [5] All other registers shall be initialized by the startup code
*
* @param[in] configPtr Pointer to a selected configuration structure
*
* @return void
* @api
*
* @pre The data structure including the configuration set required for initializing the GPT driver..
* @implements Gpt_Init_Activity
*/
void Gpt_Init (const Gpt_ConfigType * configPtr);
/*================================================================================================*/
#if (GPT_DEINIT_API == STD_ON)
/**
* @brief GPT driver de-initialization function.
* @details Service for de initializing all hardware timer channels to their power on reset state.
* The state of the peripheral after DeInit shall be the same as after power on reset.
* The service influences only the peripherals, which are allocated by static
* configuration and the runtime configuration set passed by the previous call of Gpt_Init()
* The driver needs to be initialized before calling Gpt_DeInit(). Otherwise, the
* function Gpt_DeInit shall raise the development error GPT_E_UNINIT and leave the desired
* de initialization functionality without any action.
*
* @api
* @return void
*
* @pre The driver needs to be initialized.
* @implements Gpt_DeInit_Activity
*/
void Gpt_DeInit(void);
#endif
/*================================================================================================*/
#if (GPT_TIME_ELAPSED_API == STD_ON)
/**
* @brief GPT driver function for fetching the elapsed timer value.
* @details Service for querying the time already elapsed.
* In one shot mode, this is the value relative to the point in time, the channel has been
* started with Gpt_StartTimer (calculated by the normal operation function by subtracting
* the current minus the initial timer value and returning the absolute value).
* In continuous mode, the function returns the timer value relative to the last timeout or
* the start of the channel.
* All time units used within the API services of the GPT driver shall be of the unit ticks.
* Usage of re-entrant capability is only allowed if the callers take care that
* there is no simultaneous usage of the same channel.
* To get times out of register values it is necessary to know the oscillator frequency, pre
* prescalers and so on. Since these settings are made in MCU and(or) in other modules it is
* not possible to calculate such times. Hence the conversions between time and ticks shall
* be part of an upper layer.
* The driver needs to be initialized before calling Gpt_GetTimeElapsed(). Otherwise, the
* function shall raise the development error GPT_E_UNINIT and return 0.
*
* @param[in] channel - channel id
*
* @return Gpt_ValueType - Elapsed Time in number of ticks
*
* @api
*
* @pre The driver needs to be initialized.
* @implements Gpt_GetTimeElapsed_Activity
*/
Gpt_ValueType Gpt_GetTimeElapsed(Gpt_ChannelType channel);
#endif
/*================================================================================================*/
#if (GPT_TIME_REMAINING_API == STD_ON)
/**
* @brief GPT driver function for fetching the remaining timer value.
* @details This function returns the timer value remaining until the next timeout period will
* expire (calculated by the normal operation function by subtracting the timeout minus
* the current timer value and returning the absolute value)
* All time units used within the API services of the GPT driver shall be of the unit ticks.
* Usage of re-entrant capability is only allowed if the callers take care that there is no
* simultaneous usage of the same channel.
* To get times out of register values it is necessary to know the oscillator frequency,
* pre-scalers and so on. Since these settings are made in MCU and(or) in other modules it is
* not possible to calculate such times. Hence the conversions between time and ticks shall
* be part of an upper layer.
* The driver needs to be initialized before calling Gpt_GetTimeRemaining(). Otherwise, the
* function shall raise the development error GPT_E_UNINIT and return 0.
*
*
* @param[in] channel - channel id
*
* @return Gpt_ValueType - Returns the time remaining until the target time is reached in number of ticks.
*
* @api
*
* @pre The driver needs to be initialized.
* @implements Gpt_GetTimeRemaining_Activity
*/
Gpt_ValueType Gpt_GetTimeRemaining(Gpt_ChannelType channel);
#endif
/*================================================================================================*/
/**
* @brief GPT driver function for starting a timer channel.
* @details The function Gpt_StartTimer shall start the selected timer channel with a defined
* time-out period.
* The function Gpt_StartTimer shall invoke the configured notification for that channel
* (see also GPT292) after the time-out period referenced via the parameter value (if
* enabled).
* All time units used within the API services of the GPT driver shall be of the unit ticks.
* In production mode no error is generated. The rational is that it adds no
* additional functionality to the driver. In this case the timer will be restarted with the
* time-out value, given as a parameter to the service.
* Usage of re-entrant capability is only allowed if the callers take care that
* there is no simultaneous usage of the same channel.
* To get times out of register values it is necessary to know the oscillator
* frequency, pre-scalers and so on. Since these settings are made in MCU and(or) in other
* modules it is not possible to calculate such times. Hence the conversions between time
* and ticks shall be part of an upper layer.
* The driver needs to be initialized before calling Gpt_StartTimer(). Otherwise, the
* function Gpt_StartTimer shall raise the development error GPT_E_UNINIT.
*
* @param[in] channel channel id
* @param[in] value time-out period (in number of ticks) after a notification or a wakeup event shall occur.
*
* @return void
* @api
* @pre The driver needs to be initialized.
* @implements Gpt_StartTimer_Activity
*/
void Gpt_StartTimer(Gpt_ChannelType channel,Gpt_ValueType value);
/*================================================================================================*/
/**
* @brief GPT driver function for stopping a timer channel.
* @details Service for stopping the selected timer channel
* Stopping a timer channel, not been started before will not return a development error
* Timer channels configured in one shot mode are stopped automatically, when the
* time-out period has expired.
* Usage of re-entrant capability is only allowed if the callers take care that
* there is no simultaneous usage of the same channel.
* The driver needs to be initialized before calling Gpt_StopTimer(). Otherwise,
* the function shall raise the development error GPT_E_UNINIT.
*
* @param[in] channel channel id
* @return void
*
* @api
* @pre The driver needs to be initialized. Gpt_StartTimer must be called before.
* @implements Gpt_StopTimer_Activity
*/
void Gpt_StopTimer(Gpt_ChannelType channel);
/*================================================================================================*/
#if (GPT_ENABLE_DISABLE_NOTIFICATION_API == STD_ON)
/**
* @brief GPT driver function for enabling the notification for a timer channel.
* @details Service for enabling the notification for a channel during runtime.
* This function can be called, while the timer is already running.
* Usage of re-entrant capability is only allowed if the callers take care that
* there is no simultaneous usage of the same channel.
* The driver needs to be initialized before calling Gpt_EnableNotification(). Otherwise,
* the function Gpt_EnableNotification shall raise the development error GPT_E_UNINIT.
*
* @param[in] channel channel id
* @return void
* @api
*
* @pre The driver needs to be initialized.
* @implements Gpt_EnableNotification_Activity
*/
void Gpt_EnableNotification(Gpt_ChannelType channel);
/*================================================================================================*/
/**
* @brief GPT driver function for disabling the notification for a timer channel.
* @details Service for disabling the notification for a channel during runtime.
* This function can be called, while the timer is already running
* When disabled, no notification will be sent. When re-enabled again, the user
* will not be notified of events, occurred while notifications have been disabled.
* Usage of re-entrant capability is only allowed if the callers take care that
* there is no simultaneous usage of the same channel.
* The driver needs to be initialized before calling Gpt_DisableNotification().
* Otherwise, the function shall raise the development error GPT_E_UNINIT.
*
* @param[in] channel channel id
* @return void
* @api
*
* @pre The driver needs to be initialized.
* @implements Gpt_DisableNotification_Activity
*/
void Gpt_DisableNotification(Gpt_ChannelType channel);
#endif
#if (GPT_WAKEUP_FUNCTIONALITY_API == STD_ON)
/*================================================================================================*/
/**
* @brief GPT driver function for setting the operation mode.
* @details Service for GPT mode selection. This service shall set the operation mode to the given
* mode parameter .
* When sleep mode is requested, the ECU State Manager calls Gpt_SetMode with mode
* parameter "GPT_MODE_SLEEP" and prepares the GPT for sleep mode. The MCU Driver is then
* putting the controller into SLEEP mode
* The driver needs to be initialized before calling Gpt_SetMode(). Otherwise, the
* function Gpt_SetMode shall raise the development error GPT_E_UNINIT.
*
* @param[in] eMode operation mode :
* - GPT_MODE_NORMAL: Normal operation mode of the GPT driver.
* - GPT_MODE_SLEEP: Sleep mode of the GPT driver (wakeup capable)
* @return void
* @api
*
* @pre The driver needs to be initialized.
* @implements Gpt_SetMode_Activity
*/
void Gpt_SetMode(Gpt_ModeType eMode);
/*================================================================================================*/
/**
* @brief GPT driver function for disabling the wakeup interrupt invocation for a timer channel.
* @details This service shall disable the wakeup interrupt invocation of a single GPT
* channel.
* Usage of re-entrant capability is only allowed if the callers take care that
* there is no simultaneous usage of the same channel.
* The driver needs to be initialized before calling Gpt_DisableWakeup(). Otherwise, the
* function Gpt_DisableWakeup shall raise the development error GPT_E_UNINIT.
*
* @param[in] channel channel id
* @return void
* @api
*
* @pre The driver needs to be initialized.
* @implements Gpt_DisableWakeup_Activity
*/
void Gpt_DisableWakeup(Gpt_ChannelType channel);
/*================================================================================================*/
/**
* @brief GPT driver function for enabling the wakeup interrupt invocation for a timer channel.
* @details This service shall re-enable the wakeup interrupt invocation of a single GPT
* channel.
* If supported by hardware and enabled, an internal hardware timer can serve as a
* wakeup source
* Usage of re-entrant capability is only allowed if the callers take care that
* there is no simultaneous usage of the same channel.
*
* @param[in] channel channel id
* @return void
* @api
*
* @pre The driver needs to be initialized. The channel must be configured as wakeup capable.
* @implements Gpt_EnableWakeup_Activity
*/
void Gpt_EnableWakeup(Gpt_ChannelType channel);
/*================================================================================================*/
/**
* @brief GPT driver function for checking if a wakeup capable GPT channel is the source for a
* wakeup event.
* @details Checks if a wakeup capable GPT channel is the source for a wakeup event and calls the ECU
* state manager service EcuM_SetWakeupEvent in case of a valid GPT channel wakeup event.
* The driver needs to be initialized before calling Gpt_CheckWakeup(). Otherwise, the
* function Gpt_CheckWakeup shall raise the development error GPT_E_UNINIT.
*
* @param[in] wakeupSource wakeup source
* @return void
* @api
*
* @pre The driver needs to be initialized. The channel must be configured as wakeup capable.
* @implements Gpt_CheckWakeup_Activity
*/
void Gpt_CheckWakeup(EcuM_WakeupSourceType wakeupSource);
#endif
/*================================================================================================*/
#if (GPT_CHANGE_NEXT_TIMEOUT_VALUE == STD_ON)
/**
* @brief The function changes the time out period value of the requested running channel.
* @details The function changes the time out period (in number of ticks) of the channel is
* running which will be used after the first compare matching.
* This is a non-autosar function.
* @param[in] channel channel id
* @param[in] value time out period (in number of ticks) after a notification shall occur
* @return void
* @pre Gpt_Init and Gpt_StartTimer must be called before.
* @implements
*/
void Gpt_ChangeNextTimeoutValue
(
Gpt_ChannelType channel,
Gpt_ValueType value
);
#endif
/*================================================================================================*/
#if (GPT_SET_CLOCK_MODE == STD_ON)
/**
* @brief This function changes the channel pre scaler.
* @details This function sets all channels pre scalers based on the input mode.
*
* @param[in] eClkMode pre scaler setting ( NORMAL or ALTERNATE )
* @return void
* @pre Gpt_Init must be called before.
*
*
*
* @implements Gpt_SetClockMode_Activity
*/
void Gpt_SetClockMode(Gpt_ClockModeType eClkMode);
#endif
/*================================================================================================*/
#if (GPT_CHAIN_MODE == STD_ON)
/**
* @brief The function enables the chain functionality for timer.
* @details The function enables the chain functionality for timer. Timer will be chained with timer n-1.
Channel 0 cannot be chained.
* This is a non-autosar function.
* @param[in] channel channel id
* @return void
* @pre Gpt_Init must be called before.
*
* @implements Gpt_Channel_EnableChainMode_Activity
*/
void Gpt_Channel_EnableChainMode(Gpt_ChannelType channel);
/*================================================================================================*/
/**
* @brief The function disables the chain functionality for timer.
* @details The function disables the chain functionality for timer. Timer will not be chained with timer n-1.
Channel 0 cannot be chained or unchained.
* This is a non-autosar function.
* @param[in] channel channel id
* @return void
* @pre Gpt_Init must be called before.
*
* @implements Gpt_Channel_DisableChainMode_Activity
*/
void Gpt_Channel_DisableChainMode(Gpt_ChannelType channel);
#endif
/*================================================================================================*/
#if(GPT_PREDEFTIMER_FUNCTIONALITY_API == STD_ON)
/**
* @brief Provides the current value of the given predefined free-running timer
* @details This function provides the current value of the given predefined free-running timer.
*
* @param[in] PredefTimer: Gpt_PredefTimerType ( GPT_PREDEF_TIMER_1US_16BIT,
* GPT_PREDEF_TIMER_1US_24BIT,
* GPT_PREDEF_TIMER_1US_32BIT
* GPT_PREDEF_TIMER_100US_32BIT)
* @param[out] TimeValuePtr: Pointer to time value destination data in RAM
* @pre Gpt_Init must be called before.
* @return returnValue - E_OK: no error has been detected.
* - E_NOT_OK: aborted due to errors.
*
*
* @implements Gpt_GetPredefTimerValue_Activity
*/
Std_ReturnType Gpt_GetPredefTimerValue
(
Gpt_PredefTimerType PredefTimer,
uint32 * TimeValuePtr
);
#endif
/**
* @internal
* @brief MemMap section
*/
#define GPT_STOP_SEC_CODE
#include "Gpt_MemMap.h"
#ifdef __cplusplus
}
#endif
/** @} */
#endif /* GPT_H */