Code cleanup

[pes-rpp/rpp-lib.git] / rpp / include / drv / fr_tms570.h

/*
 * fr.h
 *
 *  Created on: 8.7.2013
 *      Author: michal
 */

#ifndef FR_H_
#define FR_H_

#include "drv/Std_Types.h"
#include "drv/Fr_GeneralTypes.h"

/* Protocol constants */
#define cCASActionPointOffset 1         /**< Initialization value of the CAS action point offset timer. Units MT */
#define cChannelIdleDelimiter 11        /**< Duration of the channel idle delimiter. Units gdBit */
#define cClockDeviationMax 0.0015       /**< Maximum clock frequency deviation, equivalent to 1500ppm (1500ppm = 1500/1000000 = 0.0015). */
#define cCrcInitA 0xFEDCBA                      /**< Initialization vector for the calculation of the frame CRC on channel A (hexadecimal). */
#define cCrcInitB 0xABCDEF                      /**< Initialization vector for the calculation of the frame CRC on channel B (hexadecimal). */
#define cCrcPolynomial 0x5D6DCB         /**< Frame CRC polynomial (hexadecimal).*/
#define cCrcSize 24                                     /**< Size of the frame CRC calculation register. Units bits. */
#define cCycleCountMax 63                       /**< Maximum cycle counter value in a cluster. */
#define cdBSS 2                                         /**< Duration of the Byte Start Sequence. Units gdBit.*/
#define cdCAS 30                                        /**< Duration of the logical low portion of the collision avoidance symbol (CAS) and media access test symbol (MTS). Units gdBit. */
#define cdCASRxLowMin 29                        /**< Lower limit of the CAS acceptance window.  Units gdBit.*/
#define cdCycleMax 16000                        /**< Maximum cycle length. Units us. */
#define cdFES 2                                         /**< Duration of the Frame End Sequence. Units gdBit. */
#define cdFSS 1                                         /**< Duration of the Frame Start Sequence. Units gdBit. */
#define cdMaxMTNom 6                            /**< Maximum duration of a nominal macrotick. Each implementation must be able to support macroticks of at least this length. Different implementations may support higher values. Units us. */
#define cdMinMTNom 1                            /**< Minimum duration of a nominal macrotick. Each implementation must be able to support macroticks of at least this length. Different implementations may support lower values. Units us. */
#define cdWakeupMaxCollision 5          /**< Number of continuous bit times at LOW during the idle phase of a WUS that will cause a sending node to detect a wakeup collision. Units gdBit. */
#define cdWakeupSymbolTxLow 6           /**< Duration of low phase of a transmitted wakeup symbol.  Units us.*/
#define cdWakeupSymbolTxIdle 18         /**< Duration of the idle phase between two low phases inside a wakeup pattern.  Units 18.*/
#define cHCrcInit 0x01A                         /**< Initialization vector for the calculation of the header CRC on channel A or channel B (hexadecimal). */
#define cHCrcPolynomial 0x385           /**< Header CRC polynomial (hexadecimal). */
#define cHCrcSize 11                            /**< Size of header CRC calculation register.  Units bit.*/
#define cPayloadLengthMax 127           /**< Maximum length of the payload segment of a frame.  Units two-byte-words.*/
#define cMicroPerMacroMin 20            /**< Minimum number of microticks per macrotick during the offset correction phase.  Units uT.*/
#define cMicroPerMacroNomMin 40         /**< Minimum number of microticks in a nominal (uncorrected) macrotick. Units uT. */
#define cMicroPerMacroNomMax 240        /**< Maximum number of microticks in a nominal (uncorrected) macrotick. Units uT. */
#define cSamplesPerBit 8                        /**< Number of samples taken in the determination of a bit value. */
#define cSlotIDMax 2047                         /**< Highest slot ID number. */
#define cStaticSlotIDMax 1023           /**< Highest static slot ID number. */
#define cStrobeOffset 5                         /**< Sample where bit strobing is performed (first sample of a bit is considered as sample 1). */
#define cSyncNodeMax 15                         /**< Maximum number of sync nodes in a cluster. */
#define cVotingSamples 5                        /**< Numbers of samples in the voting window used for majority voting of the RxD input. */
#define cVotingDelay (cVotingSamples-1)/2       /**< Number of samples of delay between the RxD input and the majority voted output in the glitch-free case. */

#define FR_MAX_SYNC_FRAME_LIST_SIZE     15

/* Flags for indicating error during parameters check */
#define ERR_PARAM_NO_ERROR                                              0

/* Global parameters errors */
#define ERR_PARAM_gColdStartAttempts                    (1 << 1)
#define ERR_PARAM_gdActionPointOffset                   (1 << 2)
#define ERR_PARAM_gdCASRxLowMax                                 (1 << 3)
#define ERR_PARAM_gdDynamicSlotIdlePhase                (1 << 4)
#define ERR_PARAM_gdMinislot                                    (1 << 5)
#define ERR_PARAM_gdMinislotActionPointOffset   (1 << 6)
#define ERR_PARAM_gdStaticSlot                                  (1 << 7)
#define ERR_PARAM_gdTSSTransmitter                              (1 << 8)
#define ERR_PARAM_gdWakeupSymbolRxIdle                  (1 << 9)
#define ERR_PARAM_gdWakeupSymbolRxLow                   (1 << 10)
#define ERR_PARAM_gdWakeupSymbolRxWindow                (1 << 11)
#define ERR_PARAM_gdWakeupSymbolTxIdle                  (1 << 12)
#define ERR_PARAM_gdWakeupSymbolTxLow                   (1 << 13)
#define ERR_PARAM_gListenNoise                                  (1 << 14)
#define ERR_PARAM_gMacroPerCycle                                (1 << 15)
#define ERR_PARAM_gMaxWithoutClockCorrectionFatal (1 << 16)
#define ERR_PARAM_gMaxWithoutClockCorrectionPassive     (1 << 17)
#define ERR_PARAM_gNumberOfMinislots                    (1 << 18)
#define ERR_PARAM_gNumberOfStaticSlots                  (1 << 19)
#define ERR_PARAM_gOffsetCorrectionStart                (1 << 20)
#define ERR_PARAM_gPayloadLengthStatic                  (1 << 21)
#define ERR_PARAM_gSyncNodeMax                                  (1 << 22)
#define ERR_PARAM_gdNIT                                                 (1 << 23)
#define ERR_PARAM_gdSampleClockPeriod                   (1 << 24)
#define ERR_PARAM_gNetworkManagementVectorLength (1 << 25)

/* Local parameters errors */
#define ERR_PARAM_pAllowHaltDueToClock                  (1 << 1)
#define ERR_PARAM_pAllowPassiveToActive                 (1 << 2)
#define ERR_PARAM_pChannels                                             (1 << 3)
#define ERR_PARAM_pdAcceptedStartupRange                (1 << 4)
#define ERR_PARAM_pClusterDriftDamping                  (1 << 5)
#define ERR_PARAM_pDelayCompensationA                   (1 << 6)
#define ERR_PARAM_pDelayCompensationB                   (1 << 7)
#define ERR_PARAM_pdListenTimeout                               (1 << 8)
#define ERR_PARAM_pdMaxDrift                                    (1 << 9)
#define ERR_PARAM_pExternOffsetCorrection               (1 << 10)
#define ERR_PARAM_pExternRateCorrection                 (1 << 11)
#define ERR_PARAM_pKeySlotUsedForStartup                (1 << 12)
#define ERR_PARAM_pKeySlotUsedForSync                   (1 << 13)
#define ERR_PARAM_pLatestTx                                             (1 << 14)
#define ERR_PARAM_pMacroInitialOffsetA                  (1 << 15)
#define ERR_PARAM_pMacroInitialOffsetB                  (1 << 16)
#define ERR_PARAM_pMicroInitialOffsetA                  (1 << 17)
#define ERR_PARAM_pMicroInitialOffsetB                  (1 << 18)
#define ERR_PARAM_pMicroPerCycle                                (1 << 19)
#define ERR_PARAM_pRateCorrectionOut                    (1 << 20)
#define ERR_PARAM_pSingleSlotEnabled                    (1 << 21)
#define ERR_PARAM_pWakeupChannel                                (1 << 22)
#define ERR_PARAM_pWakeupPattern                                (1 << 23)
#define ERR_PARAM_pSamplesPerMicrotick                  (1 << 24)
#define ERR_PARAM_pDecodingCorrection                   (1 << 25)
#define ERR_PARAM_pOffsetCorrectionOut                  (1 << 26)

/* Message RAM parameters errors */
#define ERR_PARAM_statSegmentBufferCount                (1 << 0)
#define ERR_PARAM_dynSegmentBufferCount                 (1 << 1)
#define ERR_PARAM_fifoBufferCount                               (1 << 2)
#define ERR_PARAM_maxBuffLimit                                  (1 << 3)

/* Buffer configuration parameters errors */
#define ERR_PARAM_BUFFIFO_PAYLOAD_HIGH                  (1 << 0)
#define ERR_PARAM_BUFFIFO_NOT_RX                                (1 << 1)
#define ERR_PARAM_BUFFIFO_PAYLOAD_DIFFERS               (1 << 2)
#define ERR_PARAM_BUFFIFO_CHANNEL_DIFFERS               (1 << 3)
#define ERR_PARAM_BUFFIFO_CCFILTER_DIFFERS              (1 << 4)
#define ERR_PARAM_BUFDYN_FRAMEID_INVALID                (1 << 5)
#define ERR_PARAM_BUFDYN_PAYLOAD_HIGH                   (1 << 6)
#define ERR_PARAM_BUFSTAT_FRAMEID_INVALID               (1 << 7)
#define ERR_PARAM_BUFSTAT_PAYLOAD_HIGH                  (1 << 8)
#define ERR_PARAM_BUF_TOTAL_PAYLOAD_HIGH                (1 << 9)
#define ERR_PARAM_BUFDYN_CHANNELS                               (1 << 10)

/* Error codes for controller initialization */
#define FR_INIT_ERR_BAD_PARAM                                   (1 << 26)
#define FR_INIT_ERR_CLUSTER_CONFIG                              (1 << 27)
#define FR_INIT_ERR_NODE_CONFIG                                 (1 << 28)
#define FR_INIT_ERR_MSGRAM_CONFIG                               (1 << 29)
#define FR_INIT_ERR_BUFFPARAM_CONFIG                    (1 << 30)
#define FR_INIT_ERR_BUFF_CONFIG                                 (1 << 31)

/* Error flags for startup failures */
#define FR_STARTUP_ERR_SW_STUP_FOLLOW                   (1 << 26)
#define FR_STARTUP_ERR_CSINH_DIS                                (1 << 27)
#define FR_STARTUP_ERR_SW_STUP_READY                    (1 << 28)
#define FR_STARTUP_ERR_SW_STUP_AS_NCOLD                 (1 << 29)

/* TMS570 FlexRay related constants */
#define FR_MAX_BUFFERS_CNT      128
#define FR_FCS_LISTEN_TIMEOUT 10000000U

/* Macros with constants for FlexRay POC status, read from CCEV register */
#define FR_POCS_DEFAULT_CONFIG 0x0
#define FR_POCS_READY 0x1
#define FR_POCS_NORMAL_ACTIVE 0x2
#define FR_POCS_NORMAL_PASSIVE 0x3
#define FR_POCS_HALT 0x4
#define FR_POCS_MONITOR_MODE 0x5
#define FR_POCS_LOOPBACK 0xD
#define FR_POCS_CONFIG 0xF
#define FR_POCS_WAKEUP_STANDBY 0x10
#define FR_POCS_WAKEUP_LISTEN 0x11
#define FR_POCS_WAKEUP_SEND 0x12
#define FR_POCS_WAKEUP_DETECT 0x13
#define FR_POCS_STARTUP_PREPARE 0x20
#define FR_POCS_COLDSTART_LISTEN 0x21
#define FR_POCS_COLDSTART_COLLISION_RESOLUTION 0x22
#define FR_POCS_COLDSTART_CONSISTENCY_CHECK 0x23
#define FR_POCS_COLDSTART_GAP 0x24
#define FR_POCS_COLDSTART_JOIN 0x25
#define FR_POCS_INTEGRATION_COLDSTART_CHECK 0x26
#define FR_POCS_INTEGRATION_LISTEN 0x27
#define FR_POCS_INTEGRATION_CONSISTENCY_CHECK 0x28
#define FR_POCS_INITIALIZE_SCHEDULE 0x29
#define FR_POCS_ABORT_STARTUP 0x2A

/* Macros with constants for Wakeup status read from CCEV register */
#define FR_WSV_UNDEFINED 0x0
#define FR_WSV_RECEIVED_HEADER 0x1
#define FR_WSV_RECEIVED_WUP 0x2
#define FR_WSV_COLLISION_HEADER 0x3
#define FR_WSV_COLLISION_WUP 0x4
#define FR_WSV_COLLISION_UNKNOWN 0x5
#define FR_WSV_TRANSMITTED 0x6

/* Macros with constants for SPI communication with the bus controller */
#define FRAY_SPICMD_INIT_VAL    0xFFFF
#define FRAY_NUM_PORTS          2

/* Macros with flags for buffers configuration */
#define FRAY_BUF_MBI_EN                 0x01
#define FRAY_BUF_MBI_DIS                0x00
#define FRAY_BUF_TX_MODE_CONTINUOUS     0x02
#define FRAY_BUF_TX_MODE_SINGLE         0x00
#define FRAY_BUF_NM_EN                  0x04
#define FRAY_BUF_NM_DIS                 0x00
#define FRAY_BUF_TX                     0x08
#define FRAY_BUF_RX                     0x00
#define FRAY_BUF_CHB_EN                 0x10
#define FRAY_BUF_CHB_DIS                0x00
#define FRAY_BUF_CHA_EN                 0x20
#define FRAY_BUF_CHA_DIS                0x00
#define FRAY_BUF_SFI_EN                 0x40
#define FRAY_BUF_SFI_DIS                0x00
#define FRAY_BUF_SYNC_EN                0x80
#define FRAY_BUF_SYNC_DIS               0x00
#define FRAY_BUF_REJECT_NULL_FRAMES             0x100
#define FRAY_BUF_ACCEPT_NULL_FRAMES             0x000
#define FRAY_BUF_REJECT_STATIC_SEGMENT  0x200
#define FRAY_BUF_ACCEPT_STATIC_SEGMENT  0x000
#define FRAY_BUF_TXREQ_EN                               0x800
#define FRAY_BUF_TXREQ_DIS                              0x000

#define FR_CLUSTER_PARAMS_CNT   25
#define FR_NODE_PARAMS_CNT              26
#define FR_MSGRAM_PARAMS_CNT    5
#define FR_STATIC_BUF_PARAMS_CNT 8
#define FR_DYNAMIC_BUF_PARAMS_CNT 7
#define FR_FIFO_BUF_PARAMS_CNT 6
/**
 * This structure represents global FlexRay cluster parameters.
 * Values of all those parameters have to be equal for all nodes in cluster.
 */
typedef struct Fr_TMS570LS_ClusterConfigType_st {
        /* Protocol relevant parameters */
        uint8_t gColdStartAttempts;                                             /**< Maximum number of times a node in the cluster is permitted to attempt to start the cluster by initiating schedule synchronization. Range 2-31. */
        uint8_t gdActionPointOffset;                                    /**< Number of macroticks the action point is offset from the beginning of a static slot or symbol window. Range 1-63 MT. */
        uint8_t gdCASRxLowMax;                                                  /**< Upper limit of the CAS acceptance window. Range 67-99 MT. */
        uint8_t gdDynamicSlotIdlePhase;                                 /**< Duration of the idle phase within a dynamic slot. Range 0-2 Minislots. */
        uint8_t gdMinislot;                                                             /**< Duration of a minislot. Range 2-63 MT */
        uint8_t gdMinislotActionPointOffset;                    /**< Number of macroticks the minislot action point is offset from the beginning of a minislot. Range 1-31 MT. */
        uint16_t gdStaticSlot;                                                  /**< Duration of a static slot. Range 4-661 MT. */
        uint8_t gdTSSTransmitter;                                               /**< Number of bits in the Transmission Start Sequence. Range 3-15 gdBit. */
        uint8_t gdWakeupSymbolRxIdle;                                   /**< Number of bits used by the node to test the duration of the 'idle' portion of a received wakeup symbol. Duration is equal to (gdWakeupSymbolTxIdle - gdWakeupSymbolTxLow)/2 minus a safe part. (Collisions, clock differences, and other effects can deform the Tx-wakeup pattern.)  14-59 gdBit.*/
        uint8_t gdWakeupSymbolRxLow;                                    /**< Number of bits used by the node to test the LOW portion of a received wakeup symbol. This lower limit of zero bits has to be received to detect the LOW portion by the receiver. The duration is equal to gdWakeupSymbolTxLow minus a safe part. (Active stars, clock differences, and other effects can deform the Tx-wakeup pattern.). Range 11-59. */
        uint16_t gdWakeupSymbolRxWindow;                                /**< The size of the window used to detect wakeups. Detection of a wakeup requires a low and idle period (from one WUS) and a low period (from another WUS) to be detected entirely within a window of this size. The duration is equal to gdWakeupSymbolTxIdle + 2 * gdWakeupSymbolTxLow plus a safe part. (Clock differences and other effects can deform the Tx-wakeup pattern.). Range 76-301 gdBit.  */
        uint8_t gdWakeupSymbolTxIdle;                                   /**< Number of bits used by the node to transmit the 'idle' part of a wakeup symbol. The duration is equal to cdWakeupSymbolTxIdle.  45-180 gdBit. */
        uint8_t gdWakeupSymbolTxLow;                                    /**< Number of bits used by the node to transmit the LOW part of a wakeup symbol. The duration is equal to cdWakeupSymbolTxLow. Range 15-60 gdBit. */
        uint8_t gListenNoise;                                                   /**< Upper limit for the startup listen timeout and wakeup listen timeout in the presence of noise. It is used as a multiplier of the node parameter pdListenTimeout. Range 2-16. */
        uint16_t gMacroPerCycle;                                                /**< Number of macroticks in a communication cycle. Range 10-16000 MT. */
        uint8_t gMaxWithoutClockCorrectionFatal;                /**< Threshold used for testing the vClockCorrectionFailed counter. Defines the number of consecutive even/odd cycle pairs with missing clock correction terms that will cause the protocol to transition from the POC:normal active or POC:normal passive state into the POC:halt state. Range gMaxWithoutClockCorrectionPassive - 15 even/odd cycle pairs */
        uint8_t gMaxWithoutClockCorrectionPassive;              /**< Threshold used for testing the vClockCorrectionFailed counter. Defines the number of consecutive even/odd cycle pairs with missing clock correction terms that will cause the protocol to transition from the POC:normal active state to the POC:normal passive state. Note that gMaxWithoutClockCorrectionPassive <= gMaxWithoutClockCorrectionFatal <= 15. Range 1-15 even/odd cycle pairs.*/
        uint16_t gNumberOfMinislots;                                    /**< Number of minislots in the dynamic segment. Range 0-7986. */
        uint16_t gNumberOfStaticSlots;                                  /**< Number of static slots in the static segment. Range 2 - cStaticSlotIDMax. */
        uint16_t gOffsetCorrectionStart;                                /**< Start of the offset correction phase within the NIT, expressed as the number of macroticks from the start of cycle. Range 9-15999 MT. */
        uint8_t gPayloadLengthStatic;                                   /**< Payload length of a static frame. Range 0 - cPayloadLengthMax two-byte-words. */
        uint8_t gSyncNodeMax;                                                   /**< Maximum number of nodes that may send frames with the sync frame indicator bit set to one. Range 2 - cSyncNodeMax. */
        /* Protocol related parameters */
        uint16_t gdNIT;                                                                 /**< Duration of the Network Idle Time. Range 2-805 MT. */
        uint8_t gdSampleClockPeriod;                                    /**< Sample clock period. 0 = 0.0125, 1 = 0.025, 2 = 0.05 us. */
        uint8_t gNetworkManagementVectorLength;                 /**< Length of the Network Management vector in a cluster. Range 0-12 bytes */
} Fr_TMS570LS_ClusterConfigType;

/**
 * This structure represents local parameters of FlexRay node.
 */
typedef struct Fr_TMS570LS_NodeConfigType_st {
        /* Protocol relevant */
        boolean_t pAllowHaltDueToClock;                                 /**< Boolean flag that controls the transition to the POC:halt state due to a clock synchronization errors. If set to true, the CC is allowed to transition to POC:halt. If set to false, the CC will not transition to the POC:halt state but will enter or remain in the POC:normal passive state (self healing would still be possible). */
        uint8_t pAllowPassiveToActive;                                  /**< Number of consecutive even/odd cycle pairs that must have valid clock correction terms before the CC will be allowed to transition from the POC:normal passive state to POC:normal active state. If set to zero, the CC is not allowed to transition from POC:normal passive to POC:normal active. Range 0-31 even/odd cycle pairs. */
        Fr_ChannelType pChannels;                                               /**< Channels to which the node is connected.  */
        uint16_t pdAcceptedStartupRange;                                /**< Expanded range of measured clock deviation allowed for startup frames during integration. Range 0-1875 uT. */
        uint8_t pClusterDriftDamping;                                   /**< Local cluster drift damping factor used for rate correction. Range 0-20 uT*/
        uint16_t pDelayCompensationA;                                   /**< Value used to compensate for reception delays on the indicated channel. This covers assumed propagation delay up to cPropagationDelayMax for microticks in the range of 0.0125 μs to 0.05 μs. In practice, the minimum of the propagation delays of all sync nodes should be applied. Range 0-200 uT*/
        uint16_t pDelayCompensationB;                                   /**< Value used to compensate for reception delays on the indicated channel. This covers assumed propagation delay up to cPropagationDelayMax for microticks in the range of 0.0125 μs to 0.05 μs. In practice, the minimum of the propagation delays of all sync nodes should be applied. Range 0-200 uT*/
        uint32_t pdListenTimeout;                                               /**< Value for the startup listen timeout and wakeup listen timeout. Although this is a node local parameter, the real time equivalent of this value should be the same for all nodes in the cluster. Range 1284-1283846 uT. */
        uint16_t pdMaxDrift;                                                    /**< Maximum drift offset between two nodes that operate with unsynchronized clocks over one communication cycle. Range 2-1923 uT. */
        uint8_t pExternOffsetCorrection;                                /**< Number of microticks added or subtracted to the NIT to carry out a host-requested external offset correction. Range 0-7 uT. */
        uint8_t pExternRateCorrection;                                  /**< Number of microticks added or subtracted to the cycle to carry out a host-requested external rate correction. Range 0-7 uT. */
        boolean_t pKeySlotUsedForStartup;                               /**< Flag indicating whether the Key Slot is used to transmit a startup frame. If pKeySlotUsedForStartup is set to true then pKeySlotUsedForSync must also be set to true. */
        boolean_t pKeySlotUsedForSync;                                  /**< Flag indicating whether the Key Slot is used to transmit a sync frame. If pKeySlotUsedForStartup is set to true then pKeySlotUsedForSync must also be set to true.  */
        uint16_t pLatestTx;                                                             /**< Number of the last minislot in which a frame transmission can start in the dynamic segment. Range 0-7980 Minislot. */
        uint8_t pMacroInitialOffsetA;                                   /**< Integer number of macroticks between the static slot boundary and the following macrotick boundary of the secondary time reference point based on the nominal macrotick duration. Range 2-68 MT. */
        uint8_t pMacroInitialOffsetB;                                   /**< Integer number of macroticks between the static slot boundary and the following macrotick boundary of the secondary time reference point based on the nominal macrotick duration. Range 2-68 MT. */
        uint8_t pMicroInitialOffsetA;                                   /**< Number of microticks between the closest macrotick boundary described by pMacroInitialOffset[Ch] and the secondary time reference point. The parameter depends on pDelayCompensation[Ch] and therefore it has to be set independently for each channel. Range 0-239 uT. */
        uint8_t pMicroInitialOffsetB;                                   /**< Number of microticks between the closest macrotick boundary described by pMacroInitialOffset[Ch] and the secondary time reference point. The parameter depends on pDelayCompensation[Ch] and therefore it has to be set independently for each channel. Range 0-239 uT. */
        uint32_t pMicroPerCycle;                                                /**< Nominal number of microticks in the communication cycle of the local node. If nodes have different microtick durations this number will differ from node to node. Range 640-640000 uT */
        uint16_t pRateCorrectionOut;                                    /**< Magnitude of the maximum permissible rate correction value. Range 2-1923 uT. */
        uint16_t pOffsetCorrectionOut;                                  /**< Holds the maximum permitted offset correction value to be applied by the internal clock synchronization algorithm. Range 5-3BA2 uT. */
        boolean_t pSingleSlotEnabled;                                   /**< Flag indicating whether or not the node shall enter single slot mode following startup.  */
        Fr_ChannelType pWakeupChannel;                                  /**< Channel used by the node to send a wakeup pattern. Range A, B. */
        uint8_t pWakeupPattern;                                                 /**< Number of repetitions of the wakeup symbol that are combined to form a wakeup pattern when the node enters the POC:wakeup send state. Range 2-63. */
        /* Protocol related */
        uint8_t pSamplesPerMicrotick;                                   /**< Number of samples per microtick. Range 1,2,4. */
        uint8_t pDecodingCorrection;                                    /**< Decoding correction (in microticks). Range 0xF - 0x8F. */
} Fr_TMS570LS_NodeConfigType;

/**
 * This structure provides parameters for buffer configuration.
 */
typedef struct Fr_TMS570LS_BufferConfigType_st {
        uint32_t slotId;                                /**< Index of the slot in which this buffer will transfer or receive data. */
        uint8_t maxPayload;                             /**< Maximum data payload in buffer in 2-bytes-words. If lower than global payload maximum value, padding bytes are inserted (zeros). */
        Fr_ChannelType channel;                 /**< Channel filter control. A&B should not be seleceted for dynamic segment. */
        uint8_t cycleCounterFiltering;  /**< Cycle counter filter control. */
        boolean_t isTx;                                 /**< Tx or Rx buffer selector */
        boolean_t singleTransmit;               /**< Single-shot or continuous mode selector */
        boolean_t payloadPreambleIndicatorTr;           /**< For static segment - indicates that data section contains network management data. For dynamic segment - the first two data bytes can be used for message ID filtering (done manualy by MCU) */
        boolean_t rejectNullFrames;             /**< USED ONLY FOR FIFO - Reject every NULL frames. */
        boolean_t rejectStaticSegment;  /**< USED ONLY FOR FIFO - Accept only static segment frames. */
        boolean_t msgBufferInterrupt;   /**< Enables TX/RX interrupt for corresponding buffer*/
} Fr_TMS570LS_BufferConfigType;

typedef enum {
        FR_SB_RECONFIG_ENABLED,
        FR_SB_STAT_REC_DISABLED_STAT_TR_DISABLED,
        FR_SB_ALL_REC_DISABLED,
        FR_SB_ALL_REC_DISABLED_STAT_TR_DISABLED
} Fr_TMS570LS_SecureBuffersType;

/**
 * This data type reflect state of the FlexRay driver.
 */
typedef enum {
        FR_ST_DRV_NOT_INITIALIZED,      /**< No initialization procedure was performed, Fr_Init has to be processed at first. */
        FR_ST_DRV_INITIALIZED,          /**< Fr_Init procedure was performed, Fr_ControllerInit has to be processed now. */
        FR_ST_CTRL_INITIALIZED          /**< Fr_ControllerInit procedure was performed, driver and controller is ready for other actions */
} Fr_TMS570LS_DriverState;

/**
 * This structure contains the definition of the message RAM
 * configuration parameters.
 */
typedef struct Fr_TMS570LS_MsgRAMConfig_st {
        uint8_t statSegmentBufferCount;                                 /**< Number of buffers for static segment */
        uint8_t dynSegmentBufferCount;                                  /**< Number of bufferes for dynamic segment */
        uint8_t fifoBufferCount;                                                /**< Number of buffers for Rx fifo */
        boolean_t syncFramePayloadMultiplexEnabled;             /**< Selector of Payload multiplexing. 0 - Only message buffer 0 locked against reconfiguration; 1 - Both message buffers 0 and 1 are locked against reconfiguration. */
        Fr_TMS570LS_SecureBuffersType secureBuffers;    /**< Secure buffers against reconfiguration selector */
} Fr_TMS570LS_MsgRAMConfig;
/*
 * This type contains the definition of the implementation-specific
 * post build configuration structure for FlexRay driver in TMS570LS MCU.
 */
typedef struct Fr_TMS570LS_ConfigType_st {
        const Fr_TMS570LS_ClusterConfigType* clusterConfiguration;
        const Fr_TMS570LS_NodeConfigType* nodeConfiguration;
        const Fr_TMS570LS_MsgRAMConfig* msgRAMConfig;
        Fr_TMS570LS_BufferConfigType* staticBufferConfigs;
        Fr_TMS570LS_BufferConfigType* dynamicBufferConfigs;
        Fr_TMS570LS_BufferConfigType* fifoBufferConfigs;
} Fr_ConfigType;

/**
 * @brief Initalizes the Fr.
 *
 * The function Fr_Init shall internally store the configuration
 * address to enable subsequent API calls to access the configuration.
 *
 * @param [in] Fr_ConfigPtr Address to an Fr dependant configuration structure
 * that contains all information for operating the Fr subsequently.
 */
void Fr_Init(const Fr_ConfigType* Fr_ConfigPtr);

/**
 * @brief Initializes a FlexRay CC.
 *
 * The function Fr_ControllerInit shall perform the following tasks
 * on FlexRay CC Fr_CtrIdx:
 * 1. Switch CC into ‘POC:config’ (from any other POCState).
 * 2. Configure all FlexRay cluster and node configuration parameters (e.g., cycle
 * length, macrotick duration).
 * 3. Configure all transmit/receive resources (e.g., buffer initialization) according to
 * the frame triggering configuration parameters contained in the FrIf.
 * 4. Switch CC into ‘POC:ready’
 * 5. Return E_OK.
 *
 * @param [in] Fr_ConfigPtr Index of FlexRay CC within the context of the FlexRay Driver.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_ControllerInit(uint8_t Fr_CtrlIdx);

/**
 * @brief Starts communication.
 *
 * The function Fr_StartCommunication shall perform the following
 * tasks on FlexRay CC Fr_CtrIdx:
 * 1. Invoke the CC CHI command ‘RUN’, which initiates the startup procedure
 * within the FlexRay CC.
 * 2. Return E_OK.
 *
 * The function call of Fr_StartCommunication changes the CC POCState to
 * POC:startup which is a transitional state. In the case when communication startup
 * succeeds, the CC wil change the POCState to ‘POC:normal active’ or ‘POC:normal
 * passive’. It is not guaranteed that the FlexRay CC will reside in the ‘POC:normal
 * active’ or ‘POC:normal passive’ state after a call of the function
 * Fr_StartCommunication.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_StartCommunication(uint8_t Fr_CtrlIdx);

/**
 * @brief Invokes the CC CHI command ‘ALLOW_COLDSTART’.
 *
 * The function Fr_AllowColdstart shall perform the following tasks
 * on FlexRay CC Fr_CtrIdx:
 * 1. Invoke the CC CHI command ‘ALLOW_COLDSTART’.
 * 2. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_AllowColdstart(uint8_t Fr_CtrlIdx);

/**
 * @brief Invokes the CC CHI command 'ALL_SLOTS'.
 *
 * The function Fr_AllSlots shall perform the following tasks on
 * FlexRay CC Fr_CtrIdx:
 * 1. Invoke the CC CHI command ‘ALL_SLOTS’, which requests a switch from key
 * slot only mode to all slots transmission mode at the beginning of the next
 * communication cycle.
 * 2. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_AllSlots(uint8_t Fr_CtrlIdx);

/**
 * @brief Invokes the CC CHI command 'DEFERRED_HALT'.
 *
 * The function Fr_HaltCommunication shall perform the following
 * tasks on FlexRay CC Fr_CtrIdx:
 * 1. Invoke the CC CHI command ‘DEFERRED_HALT’.
 * 2. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */

Std_ReturnType Fr_HaltCommunication(uint8_t Fr_CtrlIdx);

/**
 * @brief Invokes the CC CHI command ‘FREEZE‘.
 *
 * The function Fr_AbortCommunication shall perform the
 * following tasks on FlexRay CC Fr_CtrIdx:
 * 1. Invoke the CC CHI command ‘FREEZE’, which immediately aborts
 * communication (if active) and changes to the POC:halt state from any
 * previous POCState.
 * 2. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_AbortCommunication(uint8_t Fr_CtrlIdx);

/**
 * @brief Invokes the CC CHI command ‘WAKEUP‘.
 *
 * The function Fr_SendWUP shall perform the following tasks on
 * FlexRay CC Fr_CtrIdx:
 * 1. Invoke the CC CHI command ‘WAKEUP’, which initiates the wakeup
 * transmission procedure on the configured FlexRay channel.
 * 2. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_SendWUP(uint8_t Fr_CtrlIdx);

/**
 * @brief Sets a wakeup channel.
 *
 * The function Fr_SetWakeupChannel shall perform the following
 * tasks on FlexRay CC Fr_CtrIdx:
 * 1. Change the CC’s POCState to POC:config by invoking the CHI command
 * ‘CONFIG’.
 * 2. Configure the wakeup channel according to parameter Fr_ChnlIdx.
 * 3. Change the CC’s POCState to POC:ready again by invoking the CHI
 * command ‘CONFIG_COMPLETE’.
 * 4. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [in] Fr_ChnlIdx Index of FlexRay channel within the context of the FlexRay CC
 * Fr_CtrlIdx. Valid values are FR_CHANNEL_A and FR_CHANNEL_B.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 *
 */
Std_ReturnType Fr_SetWakeupChannel(uint8_t Fr_CtrlIdx, Fr_ChannelType Fr_ChnlIdx);

/**
 * @brief Gets the POC status.
 *
 * The function Fr_GetPOCStatus shall perform the following
 * tasks on FlexRay CC Fr_CtrIdx:
 * 1. Query the CC’s actual POC status by reading the CHI variable ‘vPOC’ and
 * write the result to parameter Fr_POCStatusPtr.
 * 2. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [out] Fr_POCStatusPtr Address the output value is stored to.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_GetPOCStatus(uint8_t Fr_CtrlIdx, Fr_POCStatusType* Fr_POCStatusPtr);

/**
 * @brief Transmits data on the FlexRay network.
 *
 * The function Fr_TransmitTxLPdu shall perform the following
 * tasks on FlexRay CC Fr_CtrIdx:
 * 1. Figure out the physical resource (e.g., a buffer) mapped to the transmission of
 * the FlexRay frame identified by Fr_LPduIdx.
 * 2. If the transmit Lpdu supports dynamic payload length (configuration parameter
 * FrIfAllowDynamicLSduLength is set to true), then the transmission
 * resource shall be reconfigured to match the payload length Fr_LsduLength
 * passed to the API. Note that the dynamic payload length is only applicable to
 * frames within the dynamic FlexRay segment.
 * 3. Copy Fr_LsduLength bytes from address Fr_LsduPtr into the FlexRay CC’s
 * transmission resource and then activate it for transmission.
 * 4. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [in] Fr_LPduIdx This index is used to uniquely identify a FlexRay frame.
 * @param [in] Fr_LSduPtr This reference points to a buffer where the assembled LSdu to be
 * transmitted within this LPdu is stored at.
 * @param [in] Fr_LSduLength Determines the length of the data (in Bytes) to be transmitted.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_TransmitTxLPdu(uint8_t Fr_CtrlIdx, uint16_t Fr_LPduIdx, const uint8_t* Fr_LSduPtr, uint8_t Fr_LSduLength);

/**
 * @brief Cancels the already pending transmission of a LPdu contained in a controllers physical transmit resource (e.g. message buffer).
 *
 * The function Fr_CancelTxLPdu shall perform the following tasks
 * on FlexRay CC Fr_CtrIdx:
 * 1. Figure out the physical resource (e.g., a buffer) mapped to the transmission of
 * the FlexRay frame identified by Fr_LpduIdx.
 * 2. If the physical resource figured out is actively pending for transmission, then
 * the transmit request of this particular resource shall be terminated and E_OK
 * returned. If no transmission is pending E_NOT_OK shall be returned,
 * indicating that no such cancelation took place.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [in] Fr_LPduIdx This index is used to uniquely identify a FlexRay frame.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_CancelTxLPdu(uint8_t Fr_CtrlIdx, uint16_t Fr_LPduIdx);

/**
 * @brief Receives data from the FlexRay network.
 *
 * The function Fr_ReceiveRxLPdu shall perform the following
 * tasks on FlexRay CC Fr_CtrIdx:
 * 1. Figure out the physical resource (e.g., a buffer, a receive-FIFO) mapped to the
 * reception of the FlexRay frame as identified by Fr_LpduIdx.
 * 2. Figure out whether a new FlexRay frame instance has been received within
 * the receive resource as figured in bullet 1. If the receive resource is a FIFO,
 * then consume the first element out of the FIFO.
 * 3. If a new FlexRay frame has been accepted, then copy the received payload
 * data to address Fr_LsduPtr, store the number of bytes copied to
 * Fr_LsduLengthPtr and store the status FR_RECEIVED to
 * Fr_RxLPduStatusPtr. If a FIFO is used as received resource and the FIFO is
 * not empty, then store the status FR_RECEIVED_MORE_DATA_AVAILABLE
 * to Fr_RxLPduStatusPtr.
 * 4. If no new frame has been accepted, then do not copy any payload data to
 * Fr_LsduPtr, write 0 to the parameter Fr_LsduLengthPtr and store the status
 * FR_NOT_RECEIVED to Fr_RxLPduStatusPtr.
 * 5. Return E_OK.
 *
 * Only reconfigurable message buffers can be canceled.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [in] Fr_LPduIdx This index is used to uniquely identify a FlexRay frame.
 * @param [out] Fr_LSduPtr This reference points to the buffer where the LSdu to be received shall be stored.
 * @param [out] Fr_LPduStatusPtr This reference points to the memory location where the status of the LPdu shall be stored.
 * @param [out] Fr_LSduLengthPtr This reference points to the memory location where the length
 * of the LSdu (in bytes) shall be stored. This length represents
 * the number of bytes copied to Fr_LSduPtr.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_ReceiveRxLPdu(uint8_t Fr_CtrlIdx, uint16_t Fr_LPduIdx, uint8_t* Fr_LSduPtr, Fr_RxLPduStatusType* Fr_LPduStatusPtr, uint8_t* Fr_LSduLengthPtr);

/**
 * @brief Checks the transmit status of the LSdu.
 *
 * The function Fr_CheckTxLPduStatus shall perform the following
 * tasks on FlexRay CC Fr_CtrIdx:
 * 1. Figure out the physical resource (e.g., a buffer) mapped to the transmission of
 * the FlexRay frame identified by Fr_LpduIdx.
 * 2. Check whether the transmission resource as figured in bullet 1 is pending for
 * transmission.
 * 3. If a transmission request is pending, then store the status
 * FR_NOT_TRANSMITTED to Fr_TxLPduStatusPtr.
 * 4. If no transmission request is pending, then store the status
 * FR_TRANSMITTED to Fr_TxLPduStatusPtr.
 * 5. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [in] Fr_LPduIdx This index is used to uniquely identify a FlexRay frame.
 * @param [out] Fr_LPduStatusPtr This reference points to the memory location where the status of the LPdu shall be stored.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_CheckTxLPduStatus(uint8_t Fr_CtrlIdx, uint16_t Fr_LPduIdx, Fr_TxLPduStatusType* Fr_TxLPduStatusPtr);


/**
 * @brief Prepares a LPdu.
 *
 * Function Fr_Init must be called at first to initialize global arrays Fr_BuffersPtrs and Fr_BufferConfigured.
 * Fr_BuffersPtrs contains configuratin data for all buffers and Fr_BufferConfigured holds flags to check if the buffer
 * was or was not configured by some previous calling of this function.
 *
 * Buffers are identified the frame ID on which they should receive or transmit data. The function has to find an index of
 * the buffer in the Fr_BuffersPtrs array. When match between FrameID in the array and Fr_LPduIdx is found, the function
 * configures this buffer and then continues to find others occurences of the same frame ID in the array of config data.
 *
 * The function controlls if the buffer was or was not configured by some previous functin call. Already configured buffers
 * are skipped. For buffer reconfiguration (if allowed) is designed fuction Fr_ReconfigLPdu.
 *
 * The right procedure to configure static/dynamic buffers or FIFO buffers is launched according to the index of the buffer and
 * data stored in message RAM configuration register.
 *
 * The function Fr_PrepareLPdu shall perform the following tasks
 * on FlexRay CC Fr_CtrIdx:
 * 1. Figure out the physical resource (e.g., a buffer) mapped to the processing of
 * the FlexRay frame identified by Fr_LpduIdx.
 * 2. Configure the physical resource (a buffer) appropriate for Fr_LpduIdx
 * operation (SlotId, Cycle filter, payload length, header CRC, etc.) if the MCG
 * uses the reconfiguration feature9.
 * 3. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [in] Fr_LPduIdx This index is used to uniquely identify a FlexRay frame.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_PrepareLPdu(uint8_t Fr_CtrlIdx, uint16_t Fr_LPduIdx);

/**
 * @brief Reconfigures a given LPdu according to the parameters (FrameId, Channel, CycleRepetition, CycleOffset, PayloadLength, HeaderCRC) at runtime.
 *
 * The function Fr_ReconfigLPdu shall perform the following tasks
 * on FlexRay CC Fr_CtrIdx:
 * 1. Figure out the physical resource (e.g., a buffer) mapped to the processing of
 * the FlexRay frame as identified by Fr_LpduIdx.
 * 2. Configure the physical resource (a buffer) according to the parameters given
 * at the API. The Lpdu direction is statically associated with the Lpdu and
 * cannot be changed by this service.
 * 3. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [in] Fr_LPduIdx This index is used to uniquely identify a FlexRay frame.
 * @param [in] Fr_FrameId FlexRay Frame ID the FrIf_LPdu shall be configured to.
 * @param [in] Fr_ChnlIdx FlexRay Channel the FrIf_LPdu shall be configured to.
 * @param [in] Fr_CycleRepetition Cycle Repetition part of the cycle filter mechanism FrIf_LPdu shall be configured to.
 * @param [in] Fr_CycleOffset Cycle Offset part of the cycle filter mechanism FrIf_LPdu shall be configured to.
 * @param [in] Fr_PayloadLength Payloadlength in units of bytes the FrIf_LPduIdx shall be configured to.
 * @param [in] Fr_HeaderCRC Header CRC the FrIf_LPdu shall be configured to.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_ReconfigLPdu(uint8_t Fr_CtrlIdx, uint16_t Fr_LPduIdx, uint16_t Fr_FrameId, Fr_ChannelType Fr_ChnlIdx, uint8_t Fr_CycleRepetition, uint8_t Fr_CycleOffset, uint8_t Fr_PayloadLength, uint16_t Fr_HeaderCRC);


/**
 * @brief Disables the hardware resource of a LPdu for transmission/reception.
 *
 * The function Fr_DisableLPdu shall perform the following tasks
 * on FlexRay CC Fr_CtrIdx:
 * 1. Figure out the physical resource (e.g., a buffer) mapped to the processing of
 * the FlexRay frame identified by Fr_LpduIdx.
 * 2. Configure the physical resource (a buffer) in a way that it doesn’t take part in
 * the transmission/reception process.
 * 3. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [in] Fr_LPduIdx This index is used to uniquely identify a FlexRay frame.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_DisableLPdu(uint8_t Fr_CtrlIdx, uint16_t Fr_LPduIdx);

/**
 * @brief Gets the current global FlexRay time.
 *
 * The function Fr_GetGlobalTime shall perform the following
 * tasks on FlexRay CC Fr_CtrIdx:
 * 1. Read the current global FlexRay time and write it to the output parameters
 * Fr_CyclePtr and Fr_MacrotickPtr.
 * 2. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [in] Fr_LPduIdx This index is used to uniquely identify a FlexRay frame.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_GetGlobalTime(uint8_t Fr_CtrlIdx, uint8_t* Fr_CyclePtr, uint16_t* Fr_MacroTickPtr);

/**
 * @brief Gets the network management vector of the last communication cycle.
 *
 * The function Fr_GetNmVector shall perform the following tasks
 * on FlexRay CC Fr_CtrIdx:
 * 1. Read the current accrued network management vector out of the FlexRay CC
 * and then write it to the output parameter Fr_NmVectorPtr. The number of
 * bytes written to the output parameter is constant and is known at configuration
 * time (FrIf configuration parameter FrIfGNetworkManagementVectorLength).
 * 2. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [out] Fr_NmVectorPtr Address where the NmVector of the last communication cycle shall be stored.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_GetNmVector(uint8_t Fr_CtrlIdx, uint8_t* Fr_NmVectorPtr);

/**
 * @brief Gets the current number of startup frames seen on the cluster.
 *
 * The function Fr_GetNumOfStartupFrames shall perform the
 * following tasks on FlexRay CC Fr_CtrIdx:
 * 1. Read the number of aligned startup frame pairs received or transmitted during
 * the previous double cycle, aggregated across both channels and write it to the
 * output parameter Fr_NumOfStartupFramesPtr.
 * 2. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [out] Fr_NumOfStartupFramesPtr Address where the number of startup frames seen within the last even/odd cycle pair shall be stored.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_GetNumOfStartupFrames(uint8_t Fr_CtrlIdx, uint8_t* Fr_NumOfStartupFramesPtr);

/**
 * @brief Gets the current number of startup frames seen on the cluster.
 *
 * The function Fr_GetChannelStatus shall perform the following
 * tasks on FlexRay CC Fr_CtrIdx:
 * 1. Read the aggregated channel status, NIT status, symbol window status and
 * write it to the output parameter Fr_ChannelAStatusPtr/ Fr_ChannelBStatusPtr.
 * The value of *Fr_ChannelAStatusPtr / *Fr_ChannelBStatusPtr is bitcoded with
 * the following meaning (Bit 0 = LSB, Bit 15 = MSB)13:
 * Bit 0: Channel A/B aggregated channel status vSS!ValidFrame
 * Bit 1: Channel A/B aggregated channel status vSS!SyntaxError
 * Bit 2: Channel A/B aggregated channel status vSS!ContentError
 * Bit 3: Channel A/B aggregated channel status additional communication
 * Bit 4: Channel A/B aggregated channel status vSS!Bviolation
 * Bit 5: Channel A/B aggregated channel status vSS!TxConflict
 * Bit 6: Not used (0)
 * Bit 7: Not used (0)
 * Bit 8: Channel A/B symbol window status data vSS!ValidMTS
 * Bit 9: Channel A/B symbol window status data vSS!SyntaxError
 * Bit 10: Channel A/B symbol window status data vSS!Bviolation
 * Bit 11: Channel A/B symbol window status data vSS!TxConflict
 * Bit 12: Channel A/B NIT status data vSS!SyntaxError
 * Bit 13: Channel A/B NIT status data vSS!Bviolation
 * Bit 14: Not used (0)
 * Bit 15: Not used (0)
 * 2. Reset the aggregated channel status information within the FlexRay controller.
 * 3. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [out] Fr_ChannelAStatusPtr Address where the bitcoded channel A status information shall be stored.
 * @param [out] Fr_ChannelBStatusPtr Address where the bitcoded channel B status information shall be stored.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_GetChannelStatus(uint8_t Fr_CtrlIdx, uint16_t* Fr_ChannelAStatusPtr, uint16_t* Fr_ChannelBStatusPtr);

/**
 * @brief Gets the current clock correction values.
 *
 * The function Fr_GetClockCorrection shall perform the following
 * tasks on FlexRay CC Fr_CtrIdx:
 * 1. Read the rate correction value (vInterimRateCorrection14) and write it as
 * signed integer to the output parameter Fr_RateCorrectionPtr. Read the offset
 * correction value (vInterimOffsetCorrection15) and write it as signed integer to
 * the output parameter Fr_OffsetCorrectionPtr
 * 2. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [out] Fr_RateCorrectionPtr Address where the current rate correction value shall be stored.
 * @param [out] Fr_OffsetCorrectionPtr Address where the current offset correction value shall be stored.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_GetClockCorrection(uint8_t Fr_CtrlIdx, int16_t* Fr_RateCorrectionPtr, int32_t* Fr_OffsetCorrectionPtr);

/**
 * @brief Gets a list of syncframes received or transmitted on channel A and channel B via the even and odd communication cycle.
 *
 * The function Fr_ GetSyncFrameList shall perform the following
 * tasks on FlexRay CC Fr_CtrIdx:
 * 1. Read the list of syncframes received in the last even communication cycle on
 * channel A and write it as array to the memory location
 * Fr_ChannelAEvenListPtr.
 * Read the list of syncframes received in the last even communication cycle on
 * channel B and write it as array to the memory location
 * Fr_ChannelBEvenListPtr.
 * Read the list of syncframes received in the last odd communication cycle on
 * channel A and write it as array to the memory location
 * Fr_ChannelAOddListPtr.
 * Read the list of syncframes received in the last odd communication cycle on
 * channel B and write it as array to the memory location
 * Fr_ChannelBOddListPtr.
 * 2. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [in] Fr_ListSize Size of the arrays passed via parameters:
 * Fr_ChannelAEvenListPtr
 * Fr_ChannelBEvenListPtr
 * Fr_ChannelAOddListPtr
 * Fr_ChannelBOddListPtr.
 * The service must ensure to not write more entries into those arrays than granted by this parameter.
 * @param [out] Fr_ChannelAEvenListPtr Address the list of syncframes on channel A within the
 * even communication cycle is written to. The exact
 * number of elements written to the list is limited by
 * parameter Fr_ListSize.
 * Unused list elements are filled with the value '0' to indicate that no more syncframe has been seen.
 * @param [out] Fr_ChannelBEvenListPtr Address the list of syncframes on channel B within the
 * even communication cycle is written to. The exact
 * number of elements written to the list is limited by
 * parameter Fr_ListSize.
 * @param [out] Fr_ChannelAOddListPtr Address the list of syncframes on channel A within the
 * odd communication cycle is written to. The exact number
 * of elements written to the list is limited by parameter
 * Fr_ListSize.
 * Unused list elements are filled with the value '0' to indicate that no more syncframe has been seen.
 * @param [out] Fr_ChannelBOddListPtr Address the list of syncframes on channel B within the
 * odd communication cycle is written to. The exact number
 * of elements written to the list is limited by parameter
 * Fr_ListSize.
 * Unused list elements are filled with the value '0' to indicate that no more syncframe has been seen.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_GetSyncFrameList(uint8_t Fr_CtrlIdx, uint8_t Fr_ListSize, uint16_t* Fr_ChannelAEvenListPtr, uint16_t* Fr_ChannelBEvenListPtr, uint16_t* Fr_ChannelAOddListPtr, uint16_t* Fr_ChannelBOddListPtr);

/**
 * @brief Gets the wakeup received information from the FlexRay controller.
 *
 * The function Fr_GetWakeupRxStatus shall perform the
 * following tasks on FlexRay CC Fr_CtrIdx:
 * 1. Read the wakeup pattern received indicators for channel A and channel B and
 * write it to the output parameter Fr_WakeupRxStatusPtr. The value of
 * *Fr_WakeupRxStatusPtr is bitcoded with the following meaning (Bit 0 = LSB,
 * Bit 7 = MSB):
 * Bit 0: Wakeup pattern received on channel A (1), otherwise (0)
 * Bit 1: Wakeup pattern received on channel B (1), otherwise (0)
 * Bit 2: Not used (always 0)
 * Bit 3: Not used (always 0)
 * Bit 4: Not used (always 0)
 * Bit 5: Not used (always 0)
 * Bit 6: Not used (always 0)
 * Bit 7: Not used (always 0)
 * 2. Reset the wakeup received indication status information within the FlexRay
 * controller.
 * 3. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [out] Fr_WakeupRxStatusPtr Address where bitcoded wakeup reception status shall be stored.
 * Bit 0: Wakeup received on channel A indicator
 * Bit 1: Wakeup received on channel B indicator
 * Bit 2-7: Unused
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_GetWakeupRxStatus(uint8_t Fr_CtrlIdx, uint8_t* Fr_WakeupRxStatusPtr);

/**
 * @brief Sets the absolute FlexRay timer.
 *
 * The function Fr_SetAbsoluteTimer shall perform the following
 * tasks:
 * 1. Program the absolute FlexRay timer Fr_AbsTimerIdx according to the
 * parameters Fr_Cycle and Fr_Offset.
 * 2. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [in] Fr_AbsTimerIdx Index of absolute timer within the context of the FlexRay CC.
 * @param [in] Fr_Cycle Absolute cycle the timer shall elapse in.
 * @param [in] Fr_Offset Offset within cycle Fr_Cycle in units of macrotick the timer shall elapse at.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_SetAbsoluteTimer(uint8_t Fr_CtrlIdx, uint8_t Fr_AbsTimerIdx, uint8_t Fr_Cycle, uint16_t Fr_Offset);


/**
 * @brief Stops an absolute timer.
 *
 * The function Fr_CancelAbsoluteTimer shall perform the
 * following tasks:
 * 1. Stop the absolute timer Fr_AbsTimerIdx.
 * 2. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [in] Fr_AbsTimerIdx Index of absolute timer within the context of the FlexRay CC.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_CancelAbsoluteTimer(uint8_t Fr_CtrlIdx,       uint8_t Fr_AbsTimerIdx);

/**
 * @brief Enables the interrupt line of an absolute timer.
 *
 * The function Fr_EnableAbsoluteTimerIRQ shall perform the
 * following tasks:
 * 1. Enable the interrupt line related to timer Fr_AbsTimerIdx.
 * 2. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [in] Fr_AbsTimerIdx Index of absolute timer within the context of the FlexRay CC.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_EnableAbsoluteTimerIRQ(uint8_t Fr_CtrlIdx, uint8_t Fr_AbsTimerIdx);


/**
 * @brief Resets the interrupt condition of an absolute timer.
 *
 * The function Fr_AckAbsoluteTimerIRQ shall perform the
 * following tasks:
 * 1. Reset the interrupt condition of absolute timer Fr_AbsTimerIdx.
 * 2. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [in] Fr_AbsTimerIdx Index of absolute timer within the context of the FlexRay CC.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_AckAbsoluteTimerIRQ(uint8_t Fr_CtrlIdx, uint8_t Fr_AbsTimerIdx);

/**
 * @brief Disables the interrupt line of an absolute timer.
 *
 * The function Fr_DisableAbsoluteTimerIRQ shall perform the
 * following tasks:
 * 1. Disable the interrupt line related to absolute timer Fr_AbsTimerIdx.
 * 2. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [in] Fr_AbsTimerIdx Index of absolute timer within the context of the FlexRay CC.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_DisableAbsoluteTimerIRQ(uint8_t Fr_CtrlIdx, uint8_t Fr_AbsTimerIdx);

/**
 * @brief Gets IRQ status of an absolute timer.
 *
 * The function Fr_GetAbsoluteTimerIRQStatus shall perform the
 * following tasks:
 * 1. Check whether the interrupt of absolute timer Fr_AbsTimerIdx is pending.
 * Write TRUE to output parameter Fr_IRQStatusPtr in case the interrupt is
 * pending, FALSE otherwise.
 * 2. Return E_OK.
 *
 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [in] Fr_AbsTimerIdx Index of absolute timer within the context of the FlexRay CC.
 * @param [out] Fr_IRQStatusPtr Address the output value is stored to.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_GetAbsoluteTimerIRQStatus(uint8_t Fr_CtrlIdx, uint8_t Fr_AbsTimerIdx, boolean_t* Fr_IRQStatusPtr);

/**
 * @brief Returns the version information of this module.
 *
 * @param [out] VersioninfoPtr Pointer to where to store the version information of this module.
 */
void Fr_GetVersionInfo(Std_VersionInfoType* VersioninfoPtr);


/**
 * @brief Reads a FlexRay protocol configuration parameter for a particular FlexRay controller out of the module's configuration.
 *
 * The function Fr_ReadCCConfig shall perform the following tasks:
 * 1. Read the value of the configuration parameter requested by
 * Fr_ConfigParamIdx from the configuration and write it to output parameter Fr_ConfigParamValuePtr.
 * 2. Return E_OK.

 * @param [in] Fr_CtrlIdx Index of FlexRay CC within the context of the FlexRay Driver.
 * @param [in] Fr_ConfigParamIdx Index that identifies the configuration parameter to read. See macros FR_CIDX_<config_parameter_name>.
 * @param [out] Fr_ConfigParamValuePtr Address the output value is stored to.
 * @return E_OK: API call finished successfully. E_NOT_OK: API call aborted due to errors.
 */
Std_ReturnType Fr_ReadCCConfig( uint8_t Fr_CtrlIdx, uint8_t Fr_ConfigParamIdx, uint32_t* Fr_ConfigParamValuePtr);

/**
 * @brief   Function sends prepared command on SPI and stores response
 *
 * @param[in] port Index of flexray 0 or 1
 * @return 0 when success, -1 when bad parameter
 */
int Fr_spi_transfer(uint8_t port);

/**
 * @brief Returns last spi response of selected fray port
 *
 * @param[in] port Index of flexray 0 or 1
 * @return spi response or -1 when bad parameter
 */
int Fr_spi_response(uint8_t port);

/**
 * @brief Returns last spi command of selected fray port
 *
 * @param[in] port Index of flexray 0 or 1
 * @return spi command or -1 when bad parameter
 */
int Fr_spi_get_cmd(uint8_t port);

#endif /* FR_H_ */