1389 lines
65 KiB
C
1389 lines
65 KiB
C
/**
|
|
* @file module_driver_fciic.h
|
|
* @author Flagchip
|
|
* @brief FCIIC driver type definition and API
|
|
* @version 2.0.0
|
|
* @date 2024-08-20
|
|
*
|
|
* SDK Version: 2.6.0
|
|
*
|
|
|
|
* @copyright Copyright (c) 2024 Flagchip Semiconductors Co., Ltd.
|
|
*
|
|
*/
|
|
|
|
/*********************************************************************************
|
|
* Revision History:
|
|
|
|
* Version Date Initials CR# Descriptions
|
|
* --------- ---------- ------------ ---------- ---------------
|
|
* 2.0.0 2024/04/20 qxw0113 N/A First version
|
|
* 2.3.5 2025/06/25 qxw0120 N/A Update subaddress mode
|
|
*********************************************************************************/
|
|
|
|
#ifndef _DRIVER_MODULE_DRIVER__FCIIC_H_
|
|
#define _DRIVER_MODULE_DRIVER__FCIIC_H_
|
|
|
|
#include "HwA_fciic.h"
|
|
|
|
#if FCIIC_INSTANCE_COUNT > 0U
|
|
|
|
/**
|
|
* @addtogroup module_driver_fciic
|
|
* @{
|
|
*/
|
|
|
|
#include "module_driver_dma.h"
|
|
|
|
#if defined(__cplusplus)
|
|
extern "C" {
|
|
#endif
|
|
|
|
/**
|
|
* @name FCIIC API Service IDs
|
|
*
|
|
* @{
|
|
*/
|
|
|
|
#define FCIIC_MASTERCHECKFORBUSYBUS_ID 0x00 /**< ID for checking the bus busy status. */
|
|
#define FCIIC_MASTERGETDEFAULTCONFIG_ID 0x01 /**< ID for getting the default configuration. */
|
|
#define FCIIC_MASTERSETBAUDRATE_ID 0x02 /**< ID for setting the baud rate. */
|
|
#define FCIIC_MASTERINIT_ID 0x03 /**< ID for initializing the master. */
|
|
#define FCIIC_MASTERDEINIT_ID 0x04 /**< ID for deinitializing the master. */
|
|
#define FCIIC_MASTERINITHANDLE_ID 0x05 /**< ID for initializing the master handle. */
|
|
#define FCIIC_MASTERENABLEINTERRUPT_ID 0x06 /**< ID for enabling interrupts. */
|
|
#define FCIIC_MASTERCHECKANDCLEARERROR_ID 0x07 /**< ID for checking and clearing errors. */
|
|
#define FCIIC_MASTERWAITFLAG_ID 0x08 /**< ID for waiting on a flag. */
|
|
#define FCIIC_MASTERSTART_ID 0x09 /**< ID for starting the transfer. */
|
|
#define FCIIC_MASTERREPEATEDSTART_ID 0x0a /**< ID for initiating a repeated start. */
|
|
#define FCIIC_MASTERSENDSTARTCOMMAND_ID 0x0b /**< ID for sending a start command. */
|
|
#define FCIIC_MASTERSEND_ID 0x0c /**< ID for sending data. */
|
|
#define FCIIC_MASTERRECEIVE_ID 0x0d /**< ID for receiving data. */
|
|
#define FCIIC_MASTERSTOP_ID 0x0e /**< ID for stopping the transfer. */
|
|
#define FCIIC_MASTERTRANSFERABORT_ID 0x0f /**< ID for aborting the transfer. */
|
|
#define FCIIC_MASTERSETRECEIVELEN_ID 0x10 /**< ID for setting the receive length. */
|
|
#define FCIIC_MASTERTRANSMIT_ID 0x11 /**< ID for transmitting data. */
|
|
#define FCIIC_MASTERGETSTATUS_ID 0x12 /**< ID for getting the status. */
|
|
#define FCIIC_MASTERCLRSTATUS_ID 0x13 /**< ID for clearing the status. */
|
|
#define FCIIC_MASTERTRANSFERBLOCKING_ID 0x14 /**< ID for performing a blocking transfer. */
|
|
#define FCIIC_MASTERDMAPREPARE_ID 0x15 /**< ID for preparing DMA. */
|
|
#define FCIIC_MASTERDMASTOP_ID 0x16 /**< ID for stopping DMA. */
|
|
#define FCIIC_MASTERDMATRANSMIT_ID 0x17 /**< ID for DMA transmission. */
|
|
#define FCIIC_MASTERDMARECEIVE_ID 0x18 /**< ID for DMA reception. */
|
|
#define FCIIC_MASTERDMASTART_ID 0x19 /**< ID for starting DMA. */
|
|
#define FCIIC_MASTERDMASTAGENOTIFICATION_ID 0x1a /**< ID for DMA stage notification. */
|
|
#define FCIIC_MASTERDMASTAGEDATA_ID 0x1b /**< ID for DMA stage data. */
|
|
#define FCIIC_LL_MASTERDMAIRQNHANDLER_ID 0x1c /**< ID for the low-level master DMA IRQ handler. */
|
|
#define FCIIC_MASTERDMATRANSFER_ID 0x1d /**< ID for DMA transfer. */
|
|
#define FCIIC_MASTERINTERRUPTPROCESSSTOP_ID 0x1e /**< ID for processing the stop interrupt. */
|
|
#define FCIIC_MASTERINTERRUPTPROCESSTRANSMIT_ID 0x1f /**< ID for processing the transmit interrupt. */
|
|
#define FCIIC_MASTERINTERRUPTPROCESSRECEIVE_ID 0x20 /**< ID for processing the receive interrupt. */
|
|
#define FCIIC_MASTERINTERRUPTPROCESSSTART_ID 0x21 /**< ID for processing the start interrupt. */
|
|
#define FCIIC_LL_MASTERIRQNHANDLER_ID 0x22 /**< ID for the low-level master IRQ handler. */
|
|
#define FCIIC_MASTERGENERATESTARTCOMMAND_ID 0x23 /**< ID for generating a start command. */
|
|
#define FCIIC_MASTERTRANSFERNONBLOCKING_ID 0x24 /**< ID for non-blocking transfer. */
|
|
#define FCIIC_SLAVEINIT_ID 0x25 /**< ID for initializing the slave. */
|
|
#define FCIIC_SLAVELISTENING_ID 0x26 /**< ID for listening mode. */
|
|
#define FCIIC_SLAVEDEINIT_ID 0x27 /**< ID for deinitializing the slave. */
|
|
#define FCIIC_SLAVEDEINITHANDLE_ID 0x28 /**< ID for deinitializing the slave handle. */
|
|
#define FCIIC_SLAVEACK_ID 0x29 /**< ID for acknowledging. */
|
|
#define FCIIC_SLAVECLRSTATUS_ID 0x2a /**< ID for clearing the status. */
|
|
#define FCIIC_SLAVEGETSTATUS_ID 0x2b /**< ID for getting the status. */
|
|
#define FCIIC_SLAVEENABLEINTERRUPT_ID 0x2c /**< ID for enabling interrupts. */
|
|
#define FCIIC_SLAVECHECKFORBUSYBUS_ID 0x2d /**< ID for checking the bus busy status. */
|
|
#define FCIIC_SLAVECHECKANDCLEARERROR_ID 0x2e /**< ID for checking and clearing errors. */
|
|
#define FCIIC_SLAVEGETDEFAULTCONFIG_ID 0x2f /**< ID for getting the default configuration. */
|
|
#define FCIIC_SLAVERECEIVE_ID 0x30 /**< ID for receiving data. */
|
|
#define FCIIC_SLAVEGETERROR_ID 0x31 /**< ID for getting the error. */
|
|
#define FCIIC_SLAVECLRERROR_ID 0x32 /**< ID for clearing the error. */
|
|
#define FCIIC_SLAVEGETDIR_ID 0x33 /**< ID for getting the direction. */
|
|
#define FCIIC_SLAVEINTERRUPTPROCESSADDRESSMATCH_ID 0x34 /**< ID for processing address match interrupt. */
|
|
#define FCIIC_SLAVEINTERRUPTPROCESSRECEIVE_ID 0x35 /**< ID for processing the receive interrupt. */
|
|
#define FCIIC_SLAVEINTERRUPTPROCESSTRANSMIT_ID 0x36 /**< ID for processing the transmit interrupt. */
|
|
#define FCIIC_SLAVEINTERRUPTPROCESSSTOP_ID 0x37 /**< ID for processing the stop interrupt. */
|
|
#define FCIIC_LL_SLAVEIRQNHANDLER_ID 0x38 /**< ID for the low-level slave IRQ handler. */
|
|
#define FCIIC_SLAVETRANSFERNONBLOCKING_ID 0x39 /**< ID for non-blocking transfer. */
|
|
#define FCIIC_SLAVEDMAPREPARE_ID 0x3a /**< ID for preparing DMA. */
|
|
#define FCIIC_SLAVETRANSFERDMA_ID 0x3b /**< ID for DMA transfer. */
|
|
#define FCIIC_SLAVEDMASTAGENOTIFICATION_ID 0x3c /**< ID for DMA stage notification. */
|
|
#define FCIIC_SLAVESTARTDMA_ID 0x3d /**< ID for starting DMA. */
|
|
#define FCIIC_LL_SLAVEDMAIRQNHANDLER_ID 0x3e /**< ID for the low-level slave DMA IRQ handler. */
|
|
|
|
/** @}*/
|
|
|
|
|
|
/**
|
|
* @def FCIIC_E_PARAM_NULLPTR
|
|
* @brief Error code indicating a null pointer parameter.
|
|
*/
|
|
#define FCIIC_E_PARAM_NULLPTR 0x01U
|
|
|
|
/**
|
|
* @def FCIIC_E_PARAM_INSTANCE
|
|
* @brief Error code indicating an invalid instance parameter.
|
|
*/
|
|
#define FCIIC_E_PARAM_INSTANCE 0x02U
|
|
|
|
/**
|
|
* @def FCIIC_E_PARAM_CHANNEL
|
|
* @brief Error code indicating an invalid channel parameter.
|
|
*/
|
|
#define FCIIC_E_PARAM_CHANNEL 0x03U
|
|
|
|
|
|
/**
|
|
* @def FCIIC_DIR_MASK
|
|
* @brief Mask to extract the direction bit from the status register.
|
|
*/
|
|
#define FCIIC_DIR_MASK (0x1U)
|
|
|
|
/**
|
|
* @def FCIIC_MASTER_CMD_SIZE
|
|
* @brief Defines the size of the master command in bytes.
|
|
*/
|
|
#define FCIIC_MASTER_CMD_SIZE (0x8U)
|
|
|
|
/*******************************************************************************
|
|
* Definitions
|
|
******************************************************************************/
|
|
|
|
/**
|
|
* @enum FCIIC_InstanceType
|
|
* @brief Enumeration for selecting the FCIIC instance.
|
|
*/
|
|
typedef enum
|
|
{
|
|
FCIIC_INSTANCE_0 = 0U, /*!< FCIIC instance 0 is selected. Corresponds to the first available FCIIC module. */
|
|
FCIIC_INSTANCE_1 = 1U /*!< FCIIC instance 1 is selected. Corresponds to the second available FCIIC module. */
|
|
} FCIIC_InstanceType;
|
|
|
|
|
|
/**
|
|
* @enum FCIIC_StatusType
|
|
* @brief Enumerates the possible return status codes for FCIIC (Fast Communication Interface IC) operations.
|
|
*
|
|
* This enumeration defines the status values returned by FCIIC functions, indicating success or various errors
|
|
* that can occur during communication. These codes provide information about the outcome of a particular operation.
|
|
*
|
|
* @note Check the specific function documentation for the meaning of each status code in the context of the operation performed.
|
|
*/
|
|
typedef enum
|
|
{
|
|
FCIIC_SUCCESS = 0, /**< Generic status for successful completion of an operation. */
|
|
FCIIC_BUSY, /**< The FCIIC Master is already performing a transfer. */
|
|
FCIIC_IDLE, /**< The FCIIC Slave driver is currently idle, no transfer is in progress. */
|
|
FCIIC_NAK, /**< The slave device sent a Negative Acknowledge (NAK) in response to a byte. */
|
|
FCIIC_FIFOERROR, /**< FIFO underflow or overflow error occurred. */
|
|
FCIIC_BITERROR, /**< A transferred bit was not recognized on the bus. */
|
|
FCIIC_TRAMSMITORRECEIVEERROR,/**< The slave device transmit or receive Error. */
|
|
FCIIC_REPEATEDSTARTERROR, /**< The FCIIC slave not detects a repeated START condition and if the FCIIC slave matched the last address byte,but should detect. */
|
|
FCIIC_ADDRESSVALID, /**< Indicates whether the Address Status Register is valid. */
|
|
FCIIC_ARBITRATIONLOST, /**< Lost arbitration during a transfer. */
|
|
FCIIC_PINLOWTIMEOUT, /**< SCL or SDA line was held low longer than the timeout period. */
|
|
FCIIC_NOTRANSFERINPROGRESS, /**< Attempted to abort a transfer when none was in progress. */
|
|
FCIIC_DMAREQUESTFAIL, /**< DMA request failed to initiate or complete. */
|
|
FCIIC_TIMEOUT, /**< Timeout while polling for a status flag. */
|
|
FCIIC_DIRECTIONERROR, /**< Direction does not match the desired direction Error. */
|
|
FCIIC_STATEMACHINEERROR, /**< State machine error due to unknown error. */
|
|
FCIIC_OVERFLOWERROR, /**< The slave device transmit or receive byte number Error,Exceeding the maximum limit length. */
|
|
FCIIC_SLAVEDMANUMBERERROR, /**< The slave device DMA transmit or receive byte number Error,The number of bytes transferred is less or more than the number required to trigger a DMA completion interrupt. */
|
|
FCIIC_FAIL, /**< parameter error or others. */
|
|
} FCIIC_StatusType;
|
|
|
|
|
|
/**
|
|
* @enum FCIIC_MasterPinConfigType
|
|
* @brief Specifies the pin configuration options for the FCIIC Master.
|
|
*
|
|
* This enumeration defines the pin configurations for the FCIIC Master interface, which can be set to either
|
|
* open-drain mode or push-pull mode.
|
|
*/
|
|
typedef enum
|
|
{
|
|
FCIIC_OPENDRAIN = 0x0U, /**< FCIIC configured for 2-pin open-drain mode, suitable for standard and fast modes. */
|
|
FCIIC_PUSHPULL = 0x1U /**< FCIIC configured for 2-pin output-only (push-pull) mode, typically used for ultra-fast mode. */
|
|
} FCIIC_MasterPinConfigType;
|
|
|
|
|
|
/**
|
|
* @enum FCIIC_DirectionType
|
|
* @brief Specifies the direction of data transfer for the FCIIC Master.
|
|
*
|
|
* This enumeration defines the direction of data transfer for the FCIIC Master, indicating whether the operation
|
|
* is a write (transmit) or read (receive).
|
|
*/
|
|
typedef enum
|
|
{
|
|
FCIIC_WRITE = 0U, /**< Indicates a Master transmit operation, writing data to a slave. */
|
|
FCIIC_READ = 1U, /**< Indicates a Master receive operation, reading data from a slave. */
|
|
FCIIC_DIRNOCONFIG = 2U /**< Indicates no configuration for direction. */
|
|
} FCIIC_DirectionType;
|
|
|
|
/**
|
|
* @struct FCIIC_TxDataType
|
|
* @brief Structure for holding transmit data for FCIIC operations.
|
|
*
|
|
* This structure contains the necessary fields to define a transmit command and its associated data.
|
|
*/
|
|
typedef struct
|
|
{
|
|
FCIIC_TX_CMDType eCmd; /**< Command type. */
|
|
uint8_t u8Data; /**< 8-bit data. */
|
|
} FCIIC_TxDataType;
|
|
|
|
|
|
/**
|
|
* @struct FCIIC_RxDataType
|
|
* @brief Structure for holding received data from FCIIC operations.
|
|
*
|
|
* This structure contains the field to store the received 8-bit data.
|
|
*/
|
|
typedef struct
|
|
{
|
|
uint8_t u8Data; /**< 8-bit data. */
|
|
} FCIIC_RxDataType;
|
|
|
|
/**
|
|
* @enum FCIIC_DmaStatusType
|
|
* @brief Specifies the status of the DMA (Direct Memory Access) for FCIIC operations.
|
|
*
|
|
* This enumeration defines the different states of the DMA for FCIIC, indicating the current or next stage of the DMA process.
|
|
*/
|
|
typedef enum
|
|
{
|
|
FCIIC_DMA_NO_CONFIG = 0U, /**< DMA mode is not configured. */
|
|
FCIIC_DMA_NEXT_STAGE_IDLE = 1U, /**< DMA next stage is idle. */
|
|
FCIIC_DMA_NEXT_STAGE_DATA = 2U, /**< DMA next stage is transmit/receive data. */
|
|
FCIIC_DMA_NEXT_STAGE_STOP = 3U, /**< DMA next stage is transmit stop. */
|
|
FCIIC_DMA_NEXT_STAGE_NOTIFICATION = 4U /**< DMA next stage is notification to the user. */
|
|
} FCIIC_DmaStatusType;
|
|
|
|
|
|
/**
|
|
* @enum FCIIC_ChannelStatusType
|
|
* @brief Specifies the status of the FCIIC channel.
|
|
*
|
|
* This enumeration defines the different states of the FCIIC channel, indicating the current state of the channel during communication.
|
|
*/
|
|
typedef enum
|
|
{
|
|
FCIIC_CH_IDLE = 0U, /**< I2C channel is idle. */
|
|
FCIIC_CH_LISTENING_READ, /**< I2C channel is listening for slave reading. */
|
|
FCIIC_CH_LISTENING, /**< I2C channel is listening for slave writing. */
|
|
FCIIC_CH_START_READ, /**< I2C channel will be reading for master. */
|
|
FCIIC_CH_START_WRITE, /**< I2C channel will be writing for master. */
|
|
FCIIC_CH_SENDING, /**< I2C channel is sending. */
|
|
FCIIC_CH_RECEIVING, /**< I2C channel is receiving. */
|
|
FCIIC_CH_TRANSFER_FINISHED, /**< I2C channel has finished transferring data. */
|
|
FCIIC_CH_ERROR_PRESENT, /**< I2C channel has an error present. */
|
|
FCIIC_CH_CLOSED, /**< I2C channel is closed. */
|
|
} FCIIC_ChannelStatusType;
|
|
|
|
|
|
/**
|
|
* @struct FCIIC_MasterConfigType
|
|
* @brief Structure for configuring the FCIIC Master.
|
|
*
|
|
* This structure contains the configuration parameters for setting up the FCIIC Master.
|
|
*/
|
|
typedef struct
|
|
{
|
|
bool bEnableMaster; /**< Enables Master mode if set to true. */
|
|
bool bDebugEnable; /**< Allows transfers to continue even when the debugger halts execution. */
|
|
uint8_t u8SdaGlitchFilterWidth; /**< Width of the SDA glitch filter in nanoseconds. Set to 0 to disable. */
|
|
uint8_t u8SclGlitchFilterWidth; /**< Width of the SCL glitch filter in nanoseconds. Set to 0 to disable. */
|
|
FCIIC_MasterPinConfigType ePinConfig; /**< Selects the pin configuration for the FCIIC pins. */
|
|
uint8_t _aligned[3]; /**< Populate Fields. */
|
|
uint32_t u32BaudRate; /**< Target baud rate in Hz for the communication. */
|
|
uint32_t u32BusIdleTimeout; /**< Bus idle timeout in nanoseconds. Set to 0 to disable timeout. */
|
|
uint32_t u32PinLowTimeout; /**< Pin low timeout in nanoseconds. Set to 0 to disable timeout. */
|
|
} FCIIC_MasterConfigType;
|
|
|
|
|
|
/**
|
|
* @brief Configuration structure for initializing the FCIIC (Fast Communication Interface IC) Slave module.
|
|
*
|
|
* This structure contains various settings to configure the FCIIC Slave module according to the desired operation.
|
|
* Initialize this structure with default values by calling the FCIIC_SlaveGetDefaultConfig() function, then modify
|
|
* the fields as needed.
|
|
*
|
|
* The structure can be declared const to store the configuration in flash memory to save RAM resources.
|
|
*/
|
|
typedef struct
|
|
{
|
|
bool bEnableSlave; /*!< Enables Slave mode if set to true. */
|
|
bool bI2cSlaveFilterEnable; /*!< Enable or disable digital filter and output delay counter for slave mode. */
|
|
bool bUsedDMA; /*!< Enable DMA mode to transfer data. */
|
|
bool bI2cSlaveAckStall; /*!< Enable SCL clock stretching when SSR[AVF] = 1. */
|
|
bool bI2cSlaveTxStall; /*!< Enable SCL clock stretching when the SSR[TDF] = 1 during a slave-transmit transfer. */
|
|
bool bI2cSlaveRxStall; /*!< Enable SCL clock stretching when SSR[RDF] = 1 during a slave-receive transfer. */
|
|
bool bI2cSlaveAdrStall; /*!< Enables Slave mode if set to true. */
|
|
uint8_t u8AddrCfg; /*!< Configure different address-matching strategies. */
|
|
uint8_t u8SdaGlitchFilterWidth; /*!< Width of the SDA glitch filter in nanoseconds. Set to 0 to disable. */
|
|
uint8_t u8SclGlitchFilterWidth; /*!< Width of the SCL glitch filter in nanoseconds. Set to 0 to disable. */
|
|
uint16_t slaveAddress; /*!< A slave address configuration. */
|
|
uint32_t u32BusIdleTimeout; /*!< Bus idle timeout in nanoseconds. Set to 0 to disable timeout. */
|
|
uint32_t u32PinLowTimeout; /*!< Pin low timeout in nanoseconds. Set to 0 to disable timeout. */
|
|
} FCIIC_SlaveConfigType;
|
|
|
|
/**
|
|
* @struct FCIIC_MasterTransferType
|
|
* @brief Structure for defining a master transfer in the FCIIC.
|
|
*
|
|
* This structure holds the configuration and data for a master transfer operation.
|
|
*/
|
|
typedef struct
|
|
{
|
|
uint8_t u8SlaveAddress; /**< The 7-bit slave address of the target device. */
|
|
FCIIC_DirectionType eDirection; /**< Transfer direction: either #FCIIC_WRITE or #FCIIC_READ. */
|
|
uint16_t u16DataSize; /**< Total number of bytes to transfer. */
|
|
uint8_t subaddressSize; /**< Size of the sub-address in bytes. Maximum is 4 bytes. */
|
|
uint32_t subaddress; /**< Sub-address for targeted register. Sent most significant byte first. */
|
|
uint8_t *pData; /**< Pointer to the buffer containing data to transfer or receive. */
|
|
} FCIIC_MasterTransferType;
|
|
|
|
/**
|
|
* @struct FCIIC_SlaveTransferType
|
|
* @brief Structure for defining a slave transfer in the FCIIC.
|
|
*
|
|
* This structure holds the configuration and data for a slave transfer operation.
|
|
*/
|
|
typedef struct
|
|
{
|
|
uint8_t u8SlaveAddress; /**< The 7-bit slave address of the target device. */
|
|
uint8_t subaddressSize; /**< Size of the sub-address in bytes. Maximum is 4 bytes. */
|
|
uint16_t u16DataSize; /**< Maximum length of bytes allowed to be transmitted,Avoiding array out-of-bounds*/
|
|
uint32_t subaddress; /**< Sub-address for targeted register. Sent most significant byte first.*/
|
|
uint8_t *pData; /**< Transfer buffer,which the buffer must be a legitimate address. */
|
|
} FCIIC_SlaveTransferType;
|
|
|
|
|
|
/**
|
|
* @brief Structure for configuring DMA for I2C Master and Slave operations.
|
|
*
|
|
* This structure holds the configuration for DMA operations in both I2C Master and Slave modes.
|
|
*/
|
|
typedef struct _FCIIC_DmaConfig
|
|
{
|
|
FCIIC_DmaStatusType u8I2cDmaNextStage; /**< Represents the next stage of the IIC DMA state machine. */
|
|
uint8_t _aligned[3]; /**< Populate Fields. */
|
|
DMA_HandleType *pDmaHandle; /**< DMA_Handle which should be initialized before using. */
|
|
} FCIIC_DmaConfigType;
|
|
|
|
/**
|
|
* @brief Structure for handling the FCIIC Master operations.
|
|
* Implements : _FCIIC_MasterHandle
|
|
*
|
|
* This structure represents the handle for managing FCIIC Master operations, including the current state and settings.
|
|
*/
|
|
typedef struct _FCIIC_MasterHandle
|
|
{
|
|
FCIIC_InstanceType eInstance; /**< I2C instance. */
|
|
uint8_t _aligned[3]; /**< Populate Fields. */
|
|
|
|
struct
|
|
{
|
|
bool bUsed; /**< Whether it is being used. */
|
|
FCIIC_DirectionType eDirection; /**< Master transfer direction. */
|
|
uint8_t u8CmdSize; /**< Master command data size, prepared for transfer. */
|
|
uint8_t u8CmdOffset; /**< Master had sent the data of size, prepared for transfer. */
|
|
uint8_t u8DmaCmdSize; /**< Master had sent the command data of size, prepared for DMA transfer. */
|
|
FCIIC_ChannelStatusType eChannelStatus; /**< Master channel current state. */
|
|
uint8_t u8DmaCmdOffset; /**< Master had sent the command data of size, prepared for DMA transfer. */
|
|
uint8_t _aligned[1]; /**< Populate Fields. */
|
|
uint16_t u16DataSize; /**< Master will transfer the size of data. */
|
|
uint16_t u16DataOffset; /**< Master had sent the command data of size. */
|
|
uint16_t u16DmaCmdData[FCIIC_MASTER_CMD_SIZE]; /**< The Master command data, prepared for DMA transfer. */
|
|
FCIIC_TX_CMDType u8Cmd[FCIIC_MASTER_CMD_SIZE]; /**< The Master data, prepared for Interrupt transfer. */
|
|
uint8_t u8CmdData[FCIIC_MASTER_CMD_SIZE]; /**< The Master command data, prepared for Interrupt transfer. */
|
|
} tStatus; /**< The field of tStatus cannot be allowed modifying by the user. */
|
|
|
|
struct
|
|
{
|
|
uint8_t *pData; /**< Pointer to transfer data. */
|
|
FCIIC_DmaConfigType *pFciicTxDmaConfig; /**< DMA config instance used for sending. */
|
|
FCIIC_DmaConfigType *pFciicRxDmaConfig; /**< DMA config instance used for receiving. */
|
|
void(*pCallback)(struct _FCIIC_MasterHandle *pFciicMasterHandle, FCIIC_StatusType status); /**< Success callback function, can be designed when successfully transferred. */
|
|
void(*pErrorCallback)(struct _FCIIC_MasterHandle *pFciicMasterHandle, FCIIC_StatusType status); /**< Error callback function, would return the error state. */
|
|
void *pUserData; /**< User data. */
|
|
} tSettings; /**< The field of tSettings allows the user to set. */
|
|
} FCIIC_MasterHandleType;
|
|
|
|
|
|
|
|
/**
|
|
* @brief Structure for handling the FCIIC Slave operations.
|
|
* Implements : _FCIIC_SlaveHandle
|
|
*
|
|
* This structure represents the handle for managing FCIIC Slave operations, including the current state and settings.
|
|
*/
|
|
typedef struct _FCIIC_SlaveHandle
|
|
{
|
|
FCIIC_InstanceType eInstance; /**< I2C instance. */
|
|
uint8_t _aligned[3]; /**< Populate Fields. */
|
|
|
|
struct
|
|
{
|
|
bool bUsed; /**< Whether it is being used. */
|
|
FCIIC_StatusType eRunStatus; /**< This field records the errors encountered in a communication. */
|
|
FCIIC_ChannelStatusType eChannelStatus; /**< salve channel current state. */
|
|
uint8_t subaddressSize; /**< Size of the sub-address in bytes. Maximum is 4 bytes. */
|
|
uint8_t curSubaddressSize; /**< Current received subaddress length. Maximum is 4 bytes. */
|
|
uint16_t u16DataSize; /**< The lengest length of data received or sent by the slave in a single communication. */
|
|
uint16_t u16DataOffset; /**< Slave had sent or received the data of size. */
|
|
uint32_t u32CurSubaddress; /**< Sub-address for targeted buffer address received from master. Sent most significant byte first.*/
|
|
uint32_t u32Subaddress; /**< Sub-address for targeted buffer address. Sent most significant byte first.*/
|
|
} tStatus; /**< The field of tStatus cannot be allowed modifying by the user. */
|
|
|
|
struct
|
|
{
|
|
uint8_t *pData; /**< Pointer to transfer data. */
|
|
FCIIC_DmaConfigType *pFciicTxDmaConfig; /**< DMA config instance used for sending. */
|
|
FCIIC_DmaConfigType *pFciicRxDmaConfig; /**< DMA config instance used for receiving. */
|
|
void(*pCallback)(struct _FCIIC_SlaveHandle *pFciicSlaveHandle); /**< Success callback function, can be designed when successfully transferred. */
|
|
void(*pErrorCallback)(struct _FCIIC_SlaveHandle *pFciicSlaveHandle); /**< Error callback function, would return the error state. */
|
|
void(*pSubAddressSendingCallback)(struct _FCIIC_SlaveHandle *pFciicSlaveHandle); /**< Subaddress sending callback function. */
|
|
void(*pSubAddressReceivingCallback)(struct _FCIIC_SlaveHandle *pFciicSlaveHandle); /**< Subaddress receving callback function. */
|
|
void *pUserData; /**< User data. */
|
|
} tSettings; /**< The field of tSettings allows the user to set. */
|
|
} FCIIC_SlaveHandleType;
|
|
|
|
|
|
/**
|
|
* @typedef FCIIC_MasterTransfer_CallbackType
|
|
* @brief Callback function type for master receive operations.
|
|
*
|
|
* This callback function is called when a master receive operation completes.
|
|
*
|
|
* @param pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
* @param Status The status of the operation.
|
|
*/
|
|
typedef void (*FCIIC_MasterTransfer_CallbackType)(struct _FCIIC_MasterHandle *pFciicMasterHandle, FCIIC_StatusType Status);
|
|
|
|
/**
|
|
* @typedef FCIIC_MasterError_CallBackType
|
|
* @brief Callback function type for master error operations.
|
|
*
|
|
* This callback function is called when an error occurs during a master operation.
|
|
*
|
|
* @param pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
* @param Status The status of the error.
|
|
*/
|
|
typedef void (*FCIIC_MasterError_CallBackType)(struct _FCIIC_MasterHandle *pFciicMasterHandle, FCIIC_StatusType Status);
|
|
|
|
/**
|
|
* @typedef FCIIC_SlaveTransfer_CallbackType
|
|
* @brief Callback function type for slave receive operations.
|
|
*
|
|
* This callback function is called when a slave receive operation completes.
|
|
*
|
|
* @param pFciicSlaveHandle Pointer to the FCIIC slave handle.
|
|
*/
|
|
typedef void (*FCIIC_SlaveTransfer_CallbackType)(struct _FCIIC_SlaveHandle *pFciicSlaveHandle);
|
|
|
|
/**
|
|
* @typedef FCIIC_SlaveError_CallBackType
|
|
* @brief Callback function type for slave error operations.
|
|
*
|
|
* This callback function is called when an error occurs during a slave operation.
|
|
*
|
|
* @param pFciicSlaveHandle Pointer to the FCIIC slave handle.
|
|
*/
|
|
typedef void (*FCIIC_SlaveError_CallBackType)(struct _FCIIC_SlaveHandle *pFciicSlaveHandle);
|
|
|
|
/**
|
|
* @typedef FCIIC_RxInterrupt_CallBackType
|
|
* @brief Callback function type for receive interrupt operations.
|
|
*
|
|
* This callback function is called when a receive interrupt occurs.
|
|
*
|
|
* @param pFciicSlaveHandle Pointer to the FCIIC slave handle.
|
|
* @param status The status of the interrupt.
|
|
*/
|
|
typedef void (*FCIIC_RxInterrupt_CallBackType)(struct _FCIIC_SlaveHandle *pFciicSlaveHandle, FCIIC_StatusType status);
|
|
|
|
/**
|
|
* @struct FCIIC_InterruptType
|
|
* @brief Structure for configuring FCIIC interrupts.
|
|
*
|
|
* This structure holds the configuration for enabling and handling interrupts in the FCIIC.
|
|
*/
|
|
typedef struct
|
|
{
|
|
uint8_t bEnErrorInterrupt; /**< Enable error interrupt. */
|
|
uint8_t bEnRxInterrupt; /**< Enable receive interrupt. */
|
|
uint8_t _aligned[6]; /**< Populate Fields. */
|
|
FCIIC_SlaveError_CallBackType pErrorNotify; /**< Error interrupt callback function address. */
|
|
FCIIC_RxInterrupt_CallBackType pRxNotify; /**< Receive interrupt callback function address. */
|
|
} FCIIC_InterruptType;
|
|
|
|
|
|
/*******************************************************************************
|
|
* API
|
|
******************************************************************************/
|
|
/**
|
|
* @brief Checks if the I2C bus is busy for the master.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC Master handle.
|
|
*
|
|
* @return FCIIC_StatusType Indicates whether the bus is busy or not.
|
|
* @retval FCIIC_SUCCESS Bus is not busy.
|
|
* @retval FCIIC_BUSY Bus is busy.
|
|
*/
|
|
FCIIC_StatusType FCIIC_MasterCheckForBusyBus(FCIIC_MasterHandleType *const pFciicMasterHandle);
|
|
|
|
/**
|
|
* @brief Initializes a default configuration for the I2C master.
|
|
*
|
|
* This function sets up the default configuration parameters for the I2C master.
|
|
*
|
|
* @param[out] pMasterConfig Pointer to the structure where the default configuration will be stored.
|
|
*
|
|
* The following configurations are set:
|
|
* - bEnableMaster: Enables the master functionality.
|
|
* - bDebugEnable: Disables debug mode by default.
|
|
* - ePinConfig: Sets the pin configuration to open-drain.
|
|
* - u32BaudRate: Sets the baud rate to 100 kHz.
|
|
* - u32BusIdleTimeout: Disables the bus idle timeout.
|
|
* - u32PinLowTimeout: Disables the pin low timeout.
|
|
* - u8SdaGlitchFilterWidth: Disables the SDA glitch filter.
|
|
* - u8SclGlitchFilterWidth: Disables the SCL glitch filter.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly.
|
|
*/
|
|
void FCIIC_MasterGetDefaultConfig(FCIIC_MasterConfigType *const pMasterConfig);
|
|
|
|
/**
|
|
* @brief Sets the baud rate for the I2C master.
|
|
*
|
|
* This function calculates and sets the baud rate for the I2C master based on the given source clock frequency and desired baud rate.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
* @param[in] sourceClock_Hz The source clock frequency in Hz.
|
|
* @param[in] pMasterConfig Pointer to the master configuration structure.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Calculates the optimal values for CLKHI, CLKLO, and PRESCALE to achieve the closest possible baud rate to the desired one.
|
|
* - Configures the MCCR and MCFGR1 registers with the calculated values.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly. It also checks if the instance is valid.
|
|
*/
|
|
void FCIIC_MasterSetBaudRate(FCIIC_MasterHandleType *const pFciicMasterHandle, uint32_t sourceClock_Hz, const FCIIC_MasterConfigType *const pMasterConfig);
|
|
|
|
|
|
/**
|
|
* @brief Initializes the I2C master with the specified configuration.
|
|
*
|
|
* This function initializes the I2C master with the provided configuration and sets up the baud rate.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
* @param[in] pMasterConfig Pointer to the master configuration structure.
|
|
* @param[in] sourceClock_Hz The source clock frequency in Hz.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Resets the I2C hardware.
|
|
* - Sets the baud rate using the `FCIIC_MasterSetBaudRate` function.
|
|
* - Configures the master control register (MCR); for debug enablement.
|
|
* - Configures the master configuration registers (MCFGR1, MCFGR2, MCFGR3); for pin configuration, glitch filters, and timeouts.
|
|
* - Enables the master operation.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointers are null and report an error accordingly. It also checks if the instance is valid.
|
|
*/
|
|
void FCIIC_MasterInit(FCIIC_MasterHandleType *const pFciicMasterHandle, const FCIIC_MasterConfigType *const pMasterConfig, uint32_t sourceClock_Hz);
|
|
|
|
|
|
/**
|
|
* @brief Deinitializes the I2C master.
|
|
*
|
|
* This function deinitializes the I2C master by resetting it and clearing its configuration.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Resets the master control register (MCR); to disable the master, reset, and clear DMA and buffer flags.
|
|
* - Disables DMA operations by setting the master DMA enable register (MDER);.
|
|
* - Clears the pin configuration and glitch filter settings in the master configuration registers (MCFGR1, MCFGR2, MCFGR3);.
|
|
* - Resets the I2C hardware.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly.
|
|
*/
|
|
void FCIIC_MasterDeinit(FCIIC_MasterHandleType *const pFciicMasterHandle);
|
|
|
|
/**
|
|
* @brief Initializes the I2C master handle.
|
|
*
|
|
* This function initializes the I2C master handle with the specified instance and clears its status and settings.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
* @param[in] eInstance The instance of the I2C master to initialize.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Sets the instance of the handle.
|
|
* - Clears the status fields including command data, direction, channel status, and offsets.
|
|
* - Sets callback functions and user data pointers to null.
|
|
* - Initializes DMA-related settings to null or zero.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly. It also checks if the instance is valid.
|
|
*/
|
|
void FCIIC_MasterInitHandle(FCIIC_MasterHandleType *const pFciicMasterHandle, FCIIC_InstanceType eInstance);
|
|
|
|
/**
|
|
* @brief Enables interrupt handling for the I2C master.
|
|
*
|
|
* This function sets the callback functions and user data for interrupt handling in the I2C master.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
* @param[in] pCallback Pointer to the transfer callback function.
|
|
* @param[in] pErrorCallback Pointer to the error callback function.
|
|
* @param[in] pUserData User-defined data to be passed to the callback functions.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Sets the transfer callback, error callback, and user data pointers in the handle's settings.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly.
|
|
*/
|
|
void FCIIC_MasterEnableInterrupt(FCIIC_MasterHandleType *const pFciicMasterHandle, FCIIC_MasterTransfer_CallbackType pCallback, FCIIC_MasterError_CallBackType pErrorCallback,
|
|
void *pUserData);
|
|
|
|
/**
|
|
* @brief Checks and clears errors in the I2C master.
|
|
*
|
|
* This function checks for specific error conditions in the I2C master and clears them if present.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
* @param[in] status The status flags to check and clear.
|
|
*
|
|
* @return FCIIC_StatusType The error status or FCIIC_SUCCESS if no errors were detected.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Checks the status flags against known error conditions.
|
|
* - Selects the appropriate error code based on the severity and type of error.
|
|
* - Clears the error flags in the I2C hardware.
|
|
* - Resets the FIFOs if necessary.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly. It also checks if the instance is valid.
|
|
*/
|
|
FCIIC_StatusType FCIIC_MasterCheckAndClearError(FCIIC_MasterHandleType *const pFciicMasterHandle, uint32_t status);
|
|
|
|
|
|
/**
|
|
* @brief Waits for a specific flag to be set in the I2C master.
|
|
*
|
|
* This function waits for a given flag to be set in the I2C master status and returns the result.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
* @param[in] u32Flag The flag to wait for.
|
|
*
|
|
* @return FCIIC_StatusType The status indicating success or timeout.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Waits for the specified flag to be set within a certain number of attempts.
|
|
* - Returns FCIIC_SUCCESS if the flag is set, or FCIIC_TIMEOUT if the flag is not set within the timeout period.
|
|
* - Checks and clears any errors that may have occurred during the wait.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly. It also checks if the instance is valid.
|
|
*/
|
|
FCIIC_StatusType FCIIC_MasterWaitFlag(FCIIC_MasterHandleType *const pFciicMasterHandle, uint32_t u32Flag);
|
|
|
|
|
|
/**
|
|
* @brief Initiates an I2C start condition.
|
|
*
|
|
* This function initiates an I2C start condition and sends the device address along with the read/write direction.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
* @param[in] address The 7-bit I2C address of the target device.
|
|
* @param[in] dir The direction of the communication (read or write);.
|
|
*
|
|
* @return FCIIC_StatusType The status indicating success or failure.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Checks if the bus is busy before starting.
|
|
* - Clears all relevant flags in the I2C hardware.
|
|
* - Sends a start condition followed by the address and direction.
|
|
* - Waits for the transmission done flag to be set.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly. It also checks if the instance is valid.
|
|
*/
|
|
FCIIC_StatusType FCIIC_MasterStart(FCIIC_MasterHandleType *const pFciicMasterHandle, uint8_t address, FCIIC_DirectionType dir);
|
|
|
|
|
|
/**
|
|
* @brief Initiates an I2C repeated start condition.
|
|
*
|
|
* This function initiates an I2C repeated start condition and sends the device address along with the read/write direction.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
* @param[in] address The 7-bit I2C address of the target device.
|
|
* @param[in] dir The direction of the communication (read or write);.
|
|
*
|
|
* @return FCIIC_StatusType The status indicating success or failure.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Sends a repeated start condition followed by the address and direction.
|
|
* - Waits for the transmission done flag to be set.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly. It also checks if the instance is valid.
|
|
*/
|
|
FCIIC_StatusType FCIIC_MasterRepeatedStart(FCIIC_MasterHandleType *const pFciicMasterHandle, uint8_t address, FCIIC_DirectionType dir);
|
|
|
|
|
|
/**
|
|
* @brief Sends a sequence of commands in the I2C master.
|
|
*
|
|
* This function sends a sequence of commands and data to the I2C bus.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
*
|
|
* @return FCIIC_StatusType The status indicating success or failure.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Iterates through each command in the command buffer.
|
|
* - Sends the command and corresponding data.
|
|
* - Waits for the transmission done flag to be set for each command.
|
|
* - Increments the command offset after each successful transmission.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly. It also checks if the instance is valid.
|
|
*/
|
|
FCIIC_StatusType FCIIC_MasterSendStartCommand(FCIIC_MasterHandleType *const pFciicMasterHandle);
|
|
|
|
|
|
/**
|
|
* @brief Sends data over the I2C bus.
|
|
*
|
|
* This function sends a block of data over the I2C bus.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
* @param[in] txBuff Pointer to the transmit buffer containing the data to send.
|
|
* @param[in] txSize The size of the data to send in bytes.
|
|
*
|
|
* @return FCIIC_StatusType The status indicating success or failure.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Iterates through each byte in the transmit buffer.
|
|
* - Sends the byte over the I2C bus.
|
|
* - Waits for the transmission done flag to be set for each byte.
|
|
* - Increments the data offset after each successful transmission.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly. It also checks if the instance is valid.
|
|
*/
|
|
FCIIC_StatusType FCIIC_MasterSend(FCIIC_MasterHandleType *const pFciicMasterHandle, uint8 *txBuff, uint16 txSize);
|
|
|
|
|
|
/**
|
|
* @brief Receives data over the I2C bus.
|
|
*
|
|
* This function receives a block of data over the I2C bus.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
*
|
|
* @return FCIIC_StatusType The status indicating success or failure.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Iterates through each byte of the receive buffer.
|
|
* - Waits for the receive data flag to be set.
|
|
* - Reads the received byte from the I2C bus.
|
|
* - Stores the received byte in the receive buffer.
|
|
* - Increments the data offset after each successful reception.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly. It also checks if the instance is valid.
|
|
*/
|
|
FCIIC_StatusType FCIIC_MasterReceive(FCIIC_MasterHandleType *const pFciicMasterHandle);
|
|
|
|
|
|
/**
|
|
* @brief Sends a stop condition over the I2C bus.
|
|
*
|
|
* This function sends a stop condition over the I2C bus.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
*
|
|
* @return FCIIC_StatusType The status indicating success or failure.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Sends a stop condition over the I2C bus.
|
|
* - Waits for the transmission done flag to be set.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly. It also checks if the instance is valid.
|
|
*/
|
|
FCIIC_StatusType FCIIC_MasterStop(FCIIC_MasterHandleType *const pFciicMasterHandle);
|
|
|
|
|
|
/**
|
|
* @brief Aborts an ongoing I2C transfer.
|
|
*
|
|
* This function aborts an ongoing I2C transfer by disabling interrupts, resetting the FIFO, and marking the handle as unused.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Disables interrupts for the I2C master.
|
|
* - Resets the FIFO.
|
|
* - Marks the handle as unused.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly. It also checks if the instance is valid.
|
|
*/
|
|
void FCIIC_MasterTransferAbort(FCIIC_MasterHandleType *const pFciicMasterHandle);
|
|
|
|
|
|
/**
|
|
* @brief Sets the receive length for an ongoing I2C transfer.
|
|
*
|
|
* This function sets the number of bytes to receive during an ongoing I2C transfer.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
* @param[in] u8Len The number of bytes to receive.
|
|
*
|
|
* @return uint8_t Returns 1 if the receive length was successfully set, otherwise 0.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Checks if the transmit count is less than 8.
|
|
* - If the condition is met, sends a receive command with the specified length minus one.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly.
|
|
*/
|
|
uint8_t FCIIC_MasterSetReceiveLen(FCIIC_MasterHandleType *const pFciicMasterHandle, uint8 u8Len);
|
|
|
|
/**
|
|
* @brief Transmits data over the I2C bus.
|
|
*
|
|
* This function transmits data over the I2C bus if the transmission data flag is set.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
* @param[in] pTxData Pointer to the transmit data structure containing the command and data to send.
|
|
*
|
|
* @return uint8_t Returns 1 if the transmission was initiated, otherwise 0.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Clears any error flags.
|
|
* - Checks the transmission data flag.
|
|
* - If the flag is set, sends the command and data.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointers are null and report an error accordingly. It also checks if the instance is valid.
|
|
*/
|
|
uint8_t FCIIC_MasterTransmit(FCIIC_MasterHandleType *const pFciicMasterHandle, FCIIC_TxDataType *pTxData);
|
|
|
|
|
|
/**
|
|
* @brief Gets the status of the I2C master.
|
|
*
|
|
* This function retrieves the status of the I2C master based on the specified status type.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
* @param[in] eStatus The status type to retrieve.
|
|
*
|
|
* @return uint8_t Returns the status value as a bit mask.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Retrieves the status based on the specified status type.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly. It also checks if the instance is valid.
|
|
*/
|
|
uint8_t FCIIC_MasterGetStatus(FCIIC_MasterHandleType *const pFciicMasterHandle, FCIIC_MasterStatusType eStatus);
|
|
|
|
/**
|
|
* @brief Clears the status flags of the I2C master.
|
|
*
|
|
* This function clears specific status flags of the I2C master.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Clears the data match flag, protocol error flag, FIFO error flag, address lost flag,
|
|
* not data flag, start detection flag, and end packet flag.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly. It also checks if the instance is valid.
|
|
*/
|
|
void FCIIC_MasterClrStatus(FCIIC_MasterHandleType *const pFciicMasterHandle);
|
|
|
|
|
|
/**
|
|
* @brief Performs a blocking I2C transfer.
|
|
*
|
|
* This function performs a blocking I2C transfer, which includes sending commands and data, and handling the transfer completion or errors.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
* @param[in] transfer Pointer to the I2C transfer parameters.
|
|
*
|
|
* @return FCIIC_StatusType Returns the status of the transfer operation.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Checks if the bus is busy or the handle is already in use.
|
|
* - Clears the status flags.
|
|
* - Initializes the handle's status fields.
|
|
* - Generates and sends the start command.
|
|
* - Sends or receives data based on the direction.
|
|
* - Sends a stop signal after the data transfer.
|
|
* - Calls the callback function upon successful transfer completion.
|
|
* - Calls the error callback function if an error occurs during the transfer.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointers are null and report an error accordingly.
|
|
*/
|
|
FCIIC_StatusType FCIIC_MasterTransferBlocking(FCIIC_MasterHandleType *const pFciicMasterHandle, FCIIC_MasterTransferType *const transfer);
|
|
|
|
/**
|
|
* @brief Prepares the DMA channel for I2C master transfer.
|
|
*
|
|
* This function prepares the DMA channel for data transfer by configuring the DMA attributes and starting the DMA transfer.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Configures the DMA channel attributes based on the transfer direction (read/write);.
|
|
* - Sets up the DMA source and destination buffers, block size, and other settings.
|
|
* - Starts the DMA transfer.
|
|
* - Updates the channel status based on the transfer direction.
|
|
* - Calls the error callback function if an error occurs during preparation.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly. It also checks if the instance is valid.
|
|
*/
|
|
void FCIIC_MasterDmaPrepare(FCIIC_MasterHandleType *const pFciicMasterHandle);
|
|
|
|
/**
|
|
* @brief Stops the DMA transfer for the I2C master.
|
|
*
|
|
* This function stops the DMA transfer by preparing a stop command and updating the DMA configuration.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Sets up the stop command in the DMA command buffer.
|
|
* - Prepares the DMA for the stop command.
|
|
* - Updates the channel status to indicate the transfer has been stopped.
|
|
* - Adjusts the next DMA stage based on the transfer direction.
|
|
* - Calls the error callback function if an error occurs during the preparation.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly. It also checks if the instance is valid.
|
|
*/
|
|
void FCIIC_MasterDmaStop(FCIIC_MasterHandleType *const pFciicMasterHandle);
|
|
|
|
/**
|
|
* @brief Initiates a DMA transmit operation for the I2C master.
|
|
*
|
|
* This function initiates the DMA transmit operation by preparing the DMA for transmission and setting the next DMA stage to stop.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Prepares the DMA for the transmit operation.
|
|
* - Sets the next DMA stage to stop after the transmission.
|
|
* - Calls the error callback function if an error occurs during preparation.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly. It also checks if the instance is valid.
|
|
*/
|
|
void FCIIC_MasterDmaTransmit(FCIIC_MasterHandleType *const pFciicMasterHandle);
|
|
|
|
|
|
/**
|
|
* @brief Initiates a DMA receive operation for the I2C master.
|
|
*
|
|
* This function initiates the DMA receive operation by preparing the DMA for reception and setting the next DMA stage to stop.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
*
|
|
* The function performs the following steps:
|
|
* - Prepares the DMA for the receive operation.
|
|
* - Sets the next DMA stage to stop after the reception.
|
|
* - Calls the error callback function if an error occurs during preparation.
|
|
*
|
|
* @note If FCIIC_DEV_ERROR_REPORT is defined as STD_ON, this function will check if the provided pointer is null and report an error accordingly. It also checks if the instance is valid.
|
|
*/
|
|
void FCIIC_MasterDmaReceive(FCIIC_MasterHandleType *const pFciicMasterHandle);
|
|
|
|
/**
|
|
* @brief Starts the DMA transfer for the FCIIC master.
|
|
*
|
|
* This function initializes the DMA command sequence based on the given transfer parameters.
|
|
* It checks for valid input parameters and then prepares the DMA commands to be sent.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle structure.
|
|
* @param[in] transfer Pointer to the FCIIC master transfer structure containing transfer details.
|
|
*/
|
|
void FCIIC_MasterDmaStart(FCIIC_MasterHandleType *const pFciicMasterHandle, FCIIC_MasterTransferType *const transfer);
|
|
|
|
|
|
/**
|
|
* @brief Handles the notification stage after a DMA transmission.
|
|
*
|
|
* This function updates the channel status and triggers a callback if one is registered.
|
|
* It also manages the next stage of DMA operations based on the direction of the transfer.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
*/
|
|
void FCIIC_MasterDmaStageNotification(FCIIC_MasterHandleType *const pFciicMasterHandle);
|
|
|
|
/**
|
|
* @brief Handles the data stage of a DMA transmission.
|
|
*
|
|
* This function updates the channel status and triggers the data transfer phase
|
|
* based on the current state and direction of the transfer.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
*/
|
|
void FCIIC_MasterDmaStageData(FCIIC_MasterHandleType *const pFciicMasterHandle);
|
|
|
|
|
|
/**
|
|
* @brief DMA interrupt handler for the FCIIC master.
|
|
*
|
|
* This function handles DMA interrupts by determining the next stage of the DMA operation,
|
|
* updating the channel status, and managing error conditions.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
*/
|
|
void FCIIC_LL_MasterDmaIRQnHandler(FCIIC_MasterHandleType *const pFciicMasterHandle);
|
|
|
|
/**
|
|
* @brief Initiates a DMA transfer for the FCIIC master.
|
|
*
|
|
* This function starts a DMA transfer by configuring the DMA settings and initiating the transfer process.
|
|
* It checks for valid parameters, ensures the bus is not busy, and configures the DMA accordingly.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
* @param[in] transfer Pointer to the FCIIC master transfer structure containing transfer details.
|
|
*
|
|
* @return FCIIC_StatusType The status of the DMA transfer initiation.
|
|
*/
|
|
FCIIC_StatusType FCIIC_MasterDmaTransfer(FCIIC_MasterHandleType *const pFciicMasterHandle, FCIIC_MasterTransferType *const transfer);
|
|
|
|
|
|
/**
|
|
* @brief Stops the interrupt process for the FCIIC master.
|
|
*
|
|
* This function disables all interrupts, updates the channel status, and triggers a callback if the data transfer is complete.
|
|
* It also handles error conditions if the data offset does not match the expected size.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
*/
|
|
void FCIIC_MasterInterruptProcessStop(FCIIC_MasterHandleType *const pFciicMasterHandle);
|
|
|
|
/**
|
|
* @brief Processes the transmit phase in interrupt mode for the FCIIC master.
|
|
*
|
|
* This function transmits data and updates the data offset. It stops the transfer and updates the channel status when the data transfer is complete.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
*/
|
|
void FCIIC_MasterInterruptProcessTransmit(FCIIC_MasterHandleType *const pFciicMasterHandle);
|
|
|
|
|
|
/**
|
|
* @brief Processes the receive phase in interrupt mode for the FCIIC master.
|
|
*
|
|
* This function receives data and updates the data offset. It stops the transfer and updates the channel status when the data reception is complete.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
*/
|
|
void FCIIC_MasterInterruptProcessReceive(FCIIC_MasterHandleType *const pFciicMasterHandle);
|
|
|
|
/**
|
|
* @brief Processes the start phase in interrupt mode for the FCIIC master.
|
|
*
|
|
* This function manages the command transmission and updates the command offset. It transitions the channel status based on the current phase of the transfer.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
*/
|
|
void FCIIC_MasterInterruptProcessStart(FCIIC_MasterHandleType *const pFciicMasterHandle);
|
|
|
|
|
|
/**
|
|
* @brief Handles the interrupt for the FCIIC master.
|
|
*
|
|
* This function processes various interrupt sources and updates the state of the transfer based on the current channel status.
|
|
* It also handles errors and calls appropriate callbacks.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC master handle.
|
|
*/
|
|
void FCIIC_LL_MasterIRQnHandler(FCIIC_MasterHandleType *const pFciicMasterHandle);
|
|
|
|
/**
|
|
* @brief Generates a start command for the FCIIC Master.
|
|
*
|
|
* This function initializes the master for transmission by generating the necessary commands for the start of a transfer.
|
|
*
|
|
* @param[in] pFciicMasterHandle The FCIIC Master Handle.
|
|
* @param[in] transfer Pointer to the `FCIIC_MasterTransferType` structure containing the transfer details.
|
|
* @return void
|
|
*/
|
|
void FCIIC_MasterGenerateStartCommand(FCIIC_MasterHandleType *const pFciicMasterHandle, FCIIC_MasterTransferType *const transfer);
|
|
|
|
/**
|
|
* @brief Initiates a non-blocking I2C Master transfer.
|
|
*
|
|
* Sets up and initiates a non-blocking I2C Master transfer, including handling of START, addressing, subaddress (if provided);,
|
|
* data transfer, and STOP conditions. Returns immediately after starting the transfer, and the transfer is managed asynchronously
|
|
* using interrupts.
|
|
*
|
|
* @param[in] pFciicMasterHandle Pointer to the FCIIC Master Handle.
|
|
* @param[in] transfer Pointer to the `FCIIC_MasterTransferType` structure containing the transfer details.
|
|
* @return A status code indicating the outcome of the initiation process:
|
|
* - FCIIC_SUCCESS: The transfer was initiated successfully.
|
|
* - FCIIC_BSY: Another non-blocking transfer is already in progress.
|
|
* - Other error codes: Errors encountered during the transfer setup, such as a busy bus.
|
|
*/
|
|
FCIIC_StatusType FCIIC_MasterTransferNonBlocking(FCIIC_MasterHandleType *const pFciicMasterHandle, FCIIC_MasterTransferType *const transfer);
|
|
|
|
/**
|
|
* @brief Initializes the I2C Slave mode.
|
|
*
|
|
* Configures the I2C interface for slave mode operation according to the parameters provided.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC Slave Handle.
|
|
* @param[in] pInitReg Pointer to the `FCIIC_SlaveConfigType` structure containing the initialization settings.
|
|
* @return void
|
|
*/
|
|
void FCIIC_SlaveInit(FCIIC_SlaveHandleType *const pFciicSlaveHandle, const FCIIC_SlaveConfigType *pInitReg);
|
|
|
|
/**
|
|
* @brief De-initializes the IIC Slave mode.
|
|
*
|
|
* This function de-initializes the IIC Slave mode by resetting the handle and disabling the slave.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the slave handle structure.
|
|
* @param[in] transfer Pointer to the I2C transfer parameters.
|
|
*
|
|
* @return FCIIC_StatusType indicating the status of the operation.
|
|
*/
|
|
FCIIC_StatusType FCIIC_Slavelistening(FCIIC_SlaveHandleType *const pFciicSlaveHandle, FCIIC_SlaveTransferType *const transfer);
|
|
|
|
/**
|
|
* @brief Deinitializes the FCIIC slave configuration.
|
|
*
|
|
* This function resets the FCIIC slave peripheral to its default state.
|
|
* It disables the FCIIC slave, clears all registers, and disables interrupts.
|
|
*
|
|
* @param pFciicSlaveHandle Pointer to the FCIIC slave handle structure.
|
|
*/
|
|
void FCIIC_SlaveDeInit(FCIIC_SlaveHandleType *const pFciicSlaveHandle);
|
|
|
|
/**
|
|
* @brief Deinitializes the FCIIC slave handle.
|
|
*
|
|
* This function resets the FCIIC slave handle to its default state.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC slave handle structure.
|
|
*/
|
|
void FCIIC_SlaveDeinitHandle(FCIIC_SlaveHandleType *const pFciicSlaveHandle);
|
|
|
|
/**
|
|
* @brief Sends an ACK/NACK signal in IIC Slave mode.
|
|
*
|
|
* This function sends an ACK or NACK signal based on the input parameter.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC slave handle structure.
|
|
* @param[in] bAck Boolean flag to indicate whether to send ACK (true); or NACK (false);.
|
|
*/
|
|
void FCIIC_SlaveAck(FCIIC_SlaveHandleType *const pFciicSlaveHandle, boolean bAck);
|
|
|
|
/**
|
|
* @brief Clears the I2C master status flag state.
|
|
*
|
|
* This function clears the status flags of the I2C master.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC slave handle structure.
|
|
*/
|
|
void FCIIC_SlaveClrStatus(FCIIC_SlaveHandleType *const pFciicSlaveHandle);
|
|
|
|
/**
|
|
* @brief Gets the slave SSR status.
|
|
*
|
|
* This function retrieves the current status of the slave SSR register.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC slave handle structure.
|
|
*
|
|
* @return The current SSR status as a 32-bit unsigned integer.
|
|
*/
|
|
uint32_t FCIIC_SlaveGetStatus(FCIIC_SlaveHandleType *const pFciicSlaveHandle);
|
|
|
|
|
|
/**
|
|
* @brief Enables the interrupt for the specified FCIIC Slave instance.
|
|
*
|
|
* This function configures the interrupt system to handle non-blocking transfers for the given FCIIC Slave.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC slave handle structure.
|
|
* @param[in] pCallback Pointer to a callback function that will be invoked when a non-blocking transfer completes.
|
|
* @param[in] pErrorCallBack Pointer to a callback function that will be invoked when an error occurs.
|
|
* @param[in] pUserData Pointer to user-defined data that will be passed back to the callback function when it is called.
|
|
*/
|
|
void FCIIC_SlaveEnableInterrupt(FCIIC_SlaveHandleType *const pFciicSlaveHandle,
|
|
FCIIC_SlaveTransfer_CallbackType pCallback, FCIIC_SlaveError_CallBackType pErrorCallBack, void *pUserData);
|
|
|
|
|
|
/**
|
|
* @brief Checks if the FCIIC bus is busy.
|
|
*
|
|
* This function determines if the FCIIC bus is currently busy.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC slave handle structure.
|
|
*
|
|
* @return FCIIC_StatusType indicating the bus status.
|
|
*/
|
|
FCIIC_StatusType FCIIC_SlaveCheckForBusyBus(FCIIC_SlaveHandleType *const pFciicSlaveHandle);
|
|
|
|
/**
|
|
* @brief Checks for and clears I2C Slave errors.
|
|
*
|
|
* This function checks the provided status register for any I2C Slave errors and clears them.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC slave handle structure.
|
|
* @param[in] status The current status register value.
|
|
*
|
|
* @return FCIIC_StatusType indicating the encountered error or FCIIC_SUCCESS if no error is found.
|
|
*/
|
|
FCIIC_StatusType FCIIC_SlaveCheckAndClearError(FCIIC_SlaveHandleType *const pFciicSlaveHandle, uint32_t status);
|
|
|
|
|
|
/**
|
|
* @brief Sets the default configuration for the I2C Slave.
|
|
*
|
|
* This function sets the default configuration parameters for the I2C Slave.
|
|
*
|
|
* @param[in] slaveConfig Pointer to the configuration structure.
|
|
* @param[in] bUsedDMA Boolean flag indicating whether DMA is used.
|
|
*/
|
|
void FCIIC_SlaveGetDefaultConfig(FCIIC_SlaveConfigType *const slaveConfig, boolean bUsedDMA);
|
|
|
|
/**
|
|
* @brief Receives data in IIC Slave mode.
|
|
*
|
|
* This function receives data when polling (not used when RX interrupt is enabled); in Slave mode.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC slave handle structure.
|
|
* @param[out] pData Pointer to the data buffer where the received data will be stored.
|
|
*
|
|
* @return 0 if successful, non-zero otherwise.
|
|
*/
|
|
uint8_t FCIIC_SlaveReceive(FCIIC_SlaveHandleType *const pFciicSlaveHandle, uint8_t *pData);
|
|
|
|
/**
|
|
* @brief Gets the slave error value.
|
|
*
|
|
* This function retrieves the current error value of the slave.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC slave handle structure.
|
|
*
|
|
* @return The current error value as a 32-bit unsigned integer.
|
|
*/
|
|
uint32_t FCIIC_SlaveGetError(FCIIC_SlaveHandleType *const pFciicSlaveHandle);
|
|
|
|
/**
|
|
* @brief Clears the slave error value.
|
|
*
|
|
* This function clears the error value of the slave.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC slave handle structure.
|
|
*/
|
|
void FCIIC_SlaveClrError(FCIIC_SlaveHandleType *const pFciicSlaveHandle);
|
|
|
|
/**
|
|
* @brief Gets the current direction of the slave.
|
|
*
|
|
* This function retrieves the current direction (read/write); of the slave.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC slave handle structure.
|
|
*
|
|
* @return The current direction as an FCIIC_DirectionType enum value.
|
|
*/
|
|
FCIIC_DirectionType FCIIC_SlaveGetDir(FCIIC_SlaveHandleType *const pFciicSlaveHandle);
|
|
|
|
|
|
/**
|
|
* @brief Processes the IIC Slave AM0F interrupt.
|
|
*
|
|
* This function processes the Address Match 0 Flag interrupt for the IIC Slave.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC slave handle structure.
|
|
* @param[in] u32IsrStatus The status of the SSR flags.
|
|
*/
|
|
void FCIIC_SlaveInterruptProcessAddressMatch(FCIIC_SlaveHandleType *const pFciicSlaveHandle,uint32 u32IsrStatus);
|
|
|
|
/**
|
|
* @brief Processes the IIC Slave RDF interrupt.
|
|
*
|
|
* This function processes the Receive Data Flag interrupt for the IIC Slave.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC slave handle structure.
|
|
*/
|
|
void FCIIC_SlaveInterruptProcessReceive(FCIIC_SlaveHandleType *const pFciicSlaveHandle);
|
|
|
|
/**
|
|
* @brief Processes IIC Slave TDF interrupt.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC Slave handle.
|
|
*/
|
|
void FCIIC_SlaveInterruptProcessTransmit(FCIIC_SlaveHandleType *const pFciicSlaveHandle);
|
|
|
|
/**
|
|
* @brief Processes IIC Slave SDF interrupt.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC Slave handle.
|
|
*/
|
|
void FCIIC_SlaveInterruptProcessStop(FCIIC_SlaveHandleType *const pFciicSlaveHandle);
|
|
|
|
|
|
/**
|
|
* @brief I2C Slave Interrupt Service Routine (ISR);.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC Slave handle.
|
|
*/
|
|
void FCIIC_LL_SlaveIRQnHandler(FCIIC_SlaveHandleType *const pFciicSlaveHandle);
|
|
|
|
/**
|
|
* @brief Starts accepting slave transfers in non-blocking mode.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC Slave handle.
|
|
*
|
|
* @return FCIIC_StatusType Status indicating whether the start was successful.
|
|
*/
|
|
FCIIC_StatusType FCIIC_SlaveTransferNonBlocking(FCIIC_SlaveHandleType *const pFciicSlaveHandle);
|
|
|
|
/**
|
|
* @brief Prepares DMA configuration for IIC Slave.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC Slave handle.
|
|
*/
|
|
|
|
void FCIIC_SlaveDmaPrepare(FCIIC_SlaveHandleType *const pFciicSlaveHandle);
|
|
|
|
|
|
/**
|
|
* @brief Initiates an IIC Slave Asynchronous DMA transfer.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC Slave handle.
|
|
*
|
|
* @return FCIIC_StatusType Status indicating whether the DMA transfer was successful.
|
|
*/
|
|
FCIIC_StatusType FCIIC_SlaveTransferDMA(FCIIC_SlaveHandleType *const pFciicSlaveHandle);
|
|
|
|
/**
|
|
* @brief Starts DMA for IIC Slave in asynchronous mode.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC Slave handle.
|
|
*/
|
|
void FCIIC_SlaveDMAStageNotification(FCIIC_SlaveHandleType *const pFciicSlaveHandle);
|
|
|
|
|
|
/**
|
|
* @brief Starts DMA for IIC Slave in asynchronous mode.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC Slave handle.
|
|
*/
|
|
void FCIIC_SlaveStartDMA(FCIIC_SlaveHandleType *const pFciicSlaveHandle);
|
|
|
|
/**
|
|
* @brief DMA handler for IIC Slave.
|
|
*
|
|
* @param[in] pFciicSlaveHandle Pointer to the FCIIC Slave handle.
|
|
*/
|
|
void FCIIC_LL_SlaveDmaIRQnHandler(FCIIC_SlaveHandleType *const pFciicSlaveHandle);
|
|
|
|
#if defined(__cplusplus)
|
|
}
|
|
#endif
|
|
|
|
/** @}*/
|
|
#endif
|
|
|
|
#endif
|