83 #if (defined (I2C_OVER_LPI2C))
87 #if (defined (I2C_OVER_FLEXIO))
92 #if (defined (I2C_OVER_I2C))
93 #include "i2c_driver.h"
96 #if (defined (I2C_OVER_SWI2C))
97 #include "swi2c_driver.h"
101 #if (defined(I2C_OVER_LPI2C))
106 static uint32_t Lpi2cStateInstanceMapping[NO_OF_LPI2C_INSTS_FOR_I2C];
108 static bool Lpi2cStateIsAllocated[NO_OF_LPI2C_INSTS_FOR_I2C];
112 #if (defined(I2C_OVER_FLEXIO))
115 static flexio_device_state_t FlexioState;
117 static uint32_t FlexioI2CStateInstanceMapping[NO_OF_FLEXIO_INSTS_FOR_I2C];
119 static bool FlexioI2CStateIsAllocated[NO_OF_FLEXIO_INSTS_FOR_I2C];
123 #if (defined(I2C_OVER_I2C))
125 i2c_master_state_t I2CMasterState[NO_OF_I2C_INSTS_FOR_I2C];
126 i2c_slave_state_t I2CSlaveState[NO_OF_I2C_INSTS_FOR_I2C];
128 static uint32_t I2CStateInstanceMapping[NO_OF_I2C_INSTS_FOR_I2C];
130 static bool I2CStateIsAllocated[NO_OF_I2C_INSTS_FOR_I2C];
134 #if (defined(I2C_OVER_SWI2C))
136 swi2c_master_state_t SWI2CMasterState[NO_OF_SWI2C_INSTS_FOR_I2C];
139 #if defined(I2C_OVER_I2C) || defined(I2C_OVER_LPI2C) || defined (I2C_OVER_FLEXIO)
146 static uint8_t I2CAllocateState(
bool* isAllocated, uint32_t* instanceMapping,
const i2c_instance_t *
const instance, uint8_t numberOfinstances)
150 for (i = 0;i < numberOfinstances;i++)
152 if (isAllocated[i] ==
false)
154 instanceMapping[i] = instance->
instIdx;
155 isAllocated[i] =
true;
164 #if defined(I2C_OVER_I2C) || defined(I2C_OVER_LPI2C) || defined (I2C_OVER_FLEXIO)
171 static void I2CFreeState(
bool* isAllocated,
const uint32_t* instanceMapping,
const i2c_instance_t *
const instance, uint8_t numberOfinstances)
175 for (i = 0;i < numberOfinstances;i++)
177 if (instanceMapping[i] == instance->
instIdx)
179 isAllocated[i] =
false;
186 #if (defined(I2C_OVER_FLEXIO))
193 static uint8_t FindFlexioState(
const i2c_instance_t *
const instance)
196 for (i = 0;i<NO_OF_FLEXIO_INSTS_FOR_I2C;i++)
198 if (FlexioI2CStateInstanceMapping[i] == instance->
instIdx)
219 #if (defined (I2C_OVER_LPI2C))
241 #if (LPI2C_HAS_FAST_PLUS_MODE)
248 #if (LPI2C_HAS_HIGH_SPEED_MODE)
255 #if (LPI2C_HAS_ULTRA_FAST_MODE)
270 index = I2CAllocateState(Lpi2cStateIsAllocated, Lpi2cStateInstanceMapping, instance, NO_OF_LPI2C_INSTS_FOR_I2C);
275 #if(defined (I2C_OVER_I2C))
276 if(instance->
instType == I2C_INST_TYPE_I2C)
278 i2c_master_user_config_t i2cConfig;
288 i2cConfig.masterCallback = config->
callback;
289 i2cConfig.callbackParam = (uint8_t *)instance->
instIdx;
291 i2cConfig.baudRate = config->
baudRate;
293 index = I2CAllocateState(I2CStateIsAllocated, I2CStateInstanceMapping, instance, NO_OF_I2C_INSTS_FOR_I2C);
294 status = I2C_DRV_MasterInit((uint8_t)instance->
instIdx, &i2cConfig, &I2CMasterState[index]);
298 #if (defined(I2C_OVER_SWI2C))
299 if(instance->
instType == I2C_INST_TYPE_SWI2C)
301 swi2c_master_user_config_t swi2cConfig;
303 swi2cConfig. baudRate = config->
baudRate;
306 swi2cConfig.sclPin = ((extension_swi2c_for_i2c_t *) config->
extension)->sclPin;
307 swi2cConfig.sdaPin = ((extension_swi2c_for_i2c_t *) config->
extension)->sdaPin;
308 swi2cConfig.sclReadPin = ((extension_swi2c_for_i2c_t *) config->
extension)->sclReadPin;
309 swi2cConfig.sdaReadPin = ((extension_swi2c_for_i2c_t *) config->
extension)->sdaReadPin;
311 status = SWI2C_DRV_MasterInit(&SWI2CMasterState[instance->
instIdx], &swi2cConfig);
318 #if(defined (I2C_OVER_FLEXIO))
343 index = I2CAllocateState(FlexioI2CStateIsAllocated, FlexioI2CStateInstanceMapping, instance, NO_OF_FLEXIO_INSTS_FOR_I2C);
364 #if (defined (I2C_OVER_LPI2C))
376 index = I2CAllocateState(Lpi2cStateIsAllocated, Lpi2cStateInstanceMapping, instance, NO_OF_LPI2C_INSTS_FOR_I2C);
382 #if (defined (I2C_OVER_I2C))
383 if(instance->
instType == I2C_INST_TYPE_I2C)
385 i2c_slave_user_config_t i2cConfig;
388 i2cConfig.slaveCallback = config->
callback;
391 index = I2CAllocateState(I2CStateIsAllocated, I2CStateInstanceMapping, instance, NO_OF_I2C_INSTS_FOR_I2C);
392 status = I2C_DRV_SlaveInit((uint8_t)instance->
instIdx, &i2cConfig, (i2c_slave_state_t*)(&I2CSlaveState[index]));
397 #if (defined (I2C_OVER_SWI2C))
398 if(instance->
instType == I2C_INST_TYPE_SWI2C)
409 #if (defined (I2C_OVER_FLEXIO))
434 #if defined (I2C_OVER_LPI2C)
442 #if defined (I2C_OVER_I2C)
443 if(instance->
instType == I2C_INST_TYPE_I2C)
445 status = I2C_DRV_MasterSendData((uint8_t)instance->
instIdx, txBuff, txSize, sendStop);
450 #if defined(I2C_OVER_SWI2C)
451 if(instance->
instType == I2C_INST_TYPE_SWI2C)
464 #if defined (I2C_OVER_FLEXIO)
470 instFlexio = FindFlexioState(instance);
471 master = &FlexioI2CState[instFlexio];
491 #if defined (I2C_OVER_LPI2C)
499 #if defined (I2C_OVER_I2C)
500 if(instance->
instType == I2C_INST_TYPE_I2C)
502 status = I2C_DRV_MasterSendDataBlocking((uint8_t)instance->
instIdx, txBuff, txSize, sendStop, timeout);
507 #if defined(I2C_OVER_SWI2C)
508 if(instance->
instType == I2C_INST_TYPE_SWI2C)
510 status = SWI2C_DRV_MasterSendDataBlocking(&SWI2CMasterState[instance->
instIdx], txBuff, txSize, sendStop);
518 #if defined (I2C_OVER_FLEXIO)
524 instFlexio = FindFlexioState(instance);
525 master = &FlexioI2CState[instFlexio];
544 #if defined(I2C_OVER_LPI2C)
551 #if defined(I2C_OVER_I2C)
552 if(instance->
instType == I2C_INST_TYPE_I2C)
554 status = I2C_DRV_MasterReceiveData((uint8_t)instance->
instIdx, rxBuff, rxSize, sendStop);
558 #if defined(I2C_OVER_SWI2C)
559 if(instance->
instType == I2C_INST_TYPE_SWI2C)
570 #if defined(I2C_OVER_FLEXIO)
576 instFlexio = FindFlexioState(instance);
577 master = &FlexioI2CState[instFlexio];
596 #if defined(I2C_OVER_LPI2C)
603 #if defined(I2C_OVER_I2C)
604 if(instance->
instType == I2C_INST_TYPE_I2C)
606 status = I2C_DRV_MasterReceiveDataBlocking((uint8_t)instance->
instIdx, rxBuff, rxSize, sendStop, timeout);
610 #if defined(I2C_OVER_SWI2C)
611 if(instance->
instType == I2C_INST_TYPE_SWI2C)
613 status = SWI2C_DRV_MasterReceiveDataBlocking(&SWI2CMasterState[instance->
instIdx], rxBuff, rxSize, sendStop);
620 #if defined(I2C_OVER_FLEXIO)
626 instFlexio = FindFlexioState(instance);
627 master = &FlexioI2CState[instFlexio];
646 #if defined(I2C_OVER_LPI2C)
652 I2CFreeState(Lpi2cStateIsAllocated, Lpi2cStateInstanceMapping, instance, NO_OF_LPI2C_INSTS_FOR_I2C);
657 #if defined(I2C_OVER_I2C)
658 if(instance->
instType == I2C_INST_TYPE_I2C)
660 status = I2C_DRV_MasterDeinit((uint8_t)instance->
instIdx);
663 I2CFreeState(I2CStateIsAllocated, I2CStateInstanceMapping, instance, NO_OF_I2C_INSTS_FOR_I2C);
668 #if defined(I2C_OVER_SWI2C)
669 if(instance->
instType == I2C_INST_TYPE_SWI2C)
676 #if defined(I2C_OVER_FLEXIO)
682 instFlexio = FindFlexioState(instance);
683 master = &FlexioI2CState[instFlexio];
687 I2CFreeState(FlexioI2CStateIsAllocated, FlexioI2CStateInstanceMapping, instance, NO_OF_FLEXIO_INSTS_FOR_I2C);
706 #if defined (I2C_OVER_LPI2C)
714 #if defined (I2C_OVER_I2C)
715 if(instance->
instType == I2C_INST_TYPE_I2C)
717 (void) I2C_DRV_MasterSetSlaveAddress((uint32_t) instance->
instIdx, address);
722 #if defined(I2C_OVER_SWI2C)
723 if(instance->
instType == I2C_INST_TYPE_SWI2C)
725 (void) SWI2C_DRV_MasterSetSlaveAddress(&SWI2CMasterState[instance->
instIdx], address);
730 #if defined (I2C_OVER_FLEXIO)
736 instFlexio = FindFlexioState(instance);
737 master = &FlexioI2CState[instFlexio];
758 uint32_t counter = 0U;
760 #if defined(I2C_OVER_LPI2C)
771 #if defined(I2C_OVER_I2C)
772 if(instance -> instType == I2C_INST_TYPE_I2C)
774 status = I2C_DRV_MasterSetBaudRate((uint32_t)instance->
instIdx, baudRate);
778 #if defined(I2C_OVER_SWI2C)
779 if(instance->
instType == I2C_INST_TYPE_SWI2C)
782 if(baudRate >= 20000U)
794 if((baudRate < 20000U) && (baudRate > 100U))
796 counter = (uint32_t)((1000000U/baudRate) - 50U)*(3U/2U);
800 (void) SWI2C_DRV_SetWaitTimeForSCLTransition(&SWI2CMasterState[instance->
instIdx], counter);
805 #if defined(I2C_OVER_FLEXIO)
814 instFlexio = FindFlexioState(instance);
815 masterFlexio = &FlexioI2CState[instFlexio];
838 #if defined (I2C_OVER_LPI2C)
849 #if defined(I2C_OVER_I2C)
850 if (instance->
instType == I2C_INST_TYPE_I2C)
852 *baudRate = I2C_DRV_MasterGetBaudRate((uint32_t)instance->
instIdx);
857 #if defined(I2C_OVER_SWI2C)
858 if(instance->
instType == I2C_INST_TYPE_SWI2C)
867 #if defined(I2C_OVER_FLEXIO)
873 instFlexio = FindFlexioState(instance);
874 master = &FlexioI2CState[instFlexio];
894 #if defined(I2C_OVER_SWI2C)
938 #if defined(I2C_OVER_LPI2C)
945 #if defined(I2C_OVER_I2C)
946 if(instance->
instType == I2C_INST_TYPE_I2C)
948 status = I2C_DRV_SlaveSendData((uint8_t)instance->
instIdx, txBuff, txSize);
952 #if defined(I2C_OVER_SWI2C)
953 if(instance->
instType == I2C_INST_TYPE_SWI2C)
963 #if defined(I2C_OVER_FLEXIO)
987 #if defined(I2C_OVER_LPI2C)
994 #if defined(I2C_OVER_I2C)
995 if(instance->
instType == I2C_INST_TYPE_I2C)
997 status = I2C_DRV_SlaveSendDataBlocking((uint8_t)instance->
instIdx, txBuff, txSize, timeout);
1001 #if defined(I2C_OVER_SWI2C)
1002 if(instance->
instType == I2C_INST_TYPE_SWI2C)
1013 #if defined(I2C_OVER_FLEXIO)
1038 #if defined(I2C_OVER_LPI2C)
1045 #if defined(I2C_OVER_I2C)
1046 if(instance->
instType == I2C_INST_TYPE_I2C)
1048 status = I2C_DRV_SlaveReceiveData((uint8_t)instance->
instIdx, rxBuff, rxSize);
1052 #if defined(I2C_OVER_SWI2C)
1053 if(instance->
instType == I2C_INST_TYPE_SWI2C)
1064 #if defined(I2C_OVER_FLEXIO)
1085 uint32_t rxSize, uint32_t timeout)
1089 #if defined(I2C_OVER_LPI2C)
1096 #if defined(I2C_OVER_I2C)
1097 if(instance->
instType == I2C_INST_TYPE_I2C)
1099 status = I2C_DRV_SlaveReceiveDataBlocking((uint8_t)instance->
instIdx, rxBuff, rxSize, timeout);
1103 #if defined(I2C_OVER_SWI2C)
1104 if(instance->
instType == I2C_INST_TYPE_SWI2C)
1115 #if defined(I2C_OVER_FLEXIO)
1139 #if defined(I2C_OVER_LPI2C)
1146 #if defined(I2C_OVER_I2C)
1147 if(instance->
instType == I2C_INST_TYPE_I2C)
1149 status = I2C_DRV_SlaveSetRxBuffer((uint8_t) instance->
instIdx, rxBuff, rxSize);
1153 #if defined(I2C_OVER_SWI2C)
1154 if(instance->
instType == I2C_INST_TYPE_SWI2C)
1164 #if defined(I2C_OVER_FLEXIO)
1188 #if defined(I2C_OVER_LPI2C)
1195 #if defined(I2C_OVER_I2C)
1196 if(instance->
instType == I2C_INST_TYPE_I2C)
1198 status = I2C_DRV_SlaveSetTxBuffer((uint8_t) instance->
instIdx, txBuff, txSize);
1202 #if defined(I2C_OVER_SWI2C)
1203 if(instance->
instType == I2C_INST_TYPE_SWI2C)
1214 #if defined(I2C_OVER_FLEXIO)
1238 #if defined(I2C_OVER_LPI2C)
1244 I2CFreeState(Lpi2cStateIsAllocated, Lpi2cStateInstanceMapping, instance, NO_OF_LPI2C_INSTS_FOR_I2C);
1249 #if defined(I2C_OVER_I2C)
1250 if(instance->
instType == I2C_INST_TYPE_I2C)
1252 status = I2C_DRV_SlaveDeinit((uint8_t)instance->
instIdx);
1255 I2CFreeState(I2CStateIsAllocated, I2CStateInstanceMapping, instance, NO_OF_I2C_INSTS_FOR_I2C);
1260 #if defined(I2C_OVER_SWI2C)
1261 if(instance->
instType == I2C_INST_TYPE_SWI2C)
1267 #if defined(I2C_OVER_FLEXIO)
1288 #if defined(I2C_OVER_LPI2C)
1296 #if defined(I2C_OVER_FLEXIO)
1300 uint32_t instFlexio;
1302 instFlexio = FindFlexioState(instance);
1303 master = FlexioI2CState[instFlexio];
1309 #if defined(I2C_OVER_SWI2C)
1310 if(instance->
instType == I2C_INST_TYPE_SWI2C)
1313 (void)bytesRemaining;
1320 #if defined(I2C_OVER_I2C)
1321 if(instance->
instType == I2C_INST_TYPE_I2C)
1323 status = I2C_DRV_MasterGetTransferStatus(instance->
instIdx);
1326 (void)bytesRemaining;
1345 #if defined(I2C_OVER_LPI2C)
1353 #if defined(I2C_OVER_FLEXIO)
1361 #if defined(I2C_OVER_SWI2C)
1362 if(instance->
instType == I2C_INST_TYPE_SWI2C)
1369 #if defined(I2C_OVER_I2C)
1370 if(instance->
instType == I2C_INST_TYPE_I2C)
1372 status = I2C_DRV_SlaveGetTransferStatus(instance->
instIdx);
1376 (void) bytesRemaining;
1393 #if defined(I2C_OVER_LPI2C)
1401 #if defined(I2C_OVER_FLEXIO)
1405 uint32_t instFlexio;
1407 instFlexio = FindFlexioState(instance);
1408 master = &FlexioI2CState[instFlexio];
1414 #if defined(I2C_OVER_SWI2C)
1415 if(instance->
instType == I2C_INST_TYPE_SWI2C)
1423 #if defined(I2C_OVER_I2C)
1424 if(instance->
instType == I2C_INST_TYPE_I2C)
1426 status = I2C_DRV_MasterAbortTransferData(instance->
instIdx);
1446 #if defined(I2C_OVER_LPI2C)
1454 #if defined(I2C_OVER_FLEXIO)
1461 #if defined(I2C_OVER_SWI2C)
1462 if(instance->
instType == I2C_INST_TYPE_SWI2C)
1469 #if defined(I2C_OVER_I2C)
1470 if(instance->
instType == I2C_INST_TYPE_I2C)
1472 status = I2C_DRV_SlaveAbortTransferData(instance->
instIdx);
status_t LPI2C_DRV_SlaveGetTransferStatus(uint32_t instance, uint32_t *bytesRemaining)
Return the current status of the I2C slave transfer.
i2c_master_callback_t callback
lpi2c_mode_t operatingMode
status_t LPI2C_DRV_MasterGetTransferStatus(uint32_t instance, uint32_t *bytesRemaining)
Return the current status of the I2C master transfer.
status_t I2C_SlaveReceiveData(const i2c_instance_t *const instance, uint8_t *rxBuff, uint32_t rxSize)
Perform a non-blocking receive transaction on the I2C bus.
status_t I2C_MasterAbortTransfer(const i2c_instance_t *const instance)
Abort a non-blocking I2C Master transmission or reception.
status_t LPI2C_DRV_MasterAbortTransferData(uint32_t instance)
Abort a non-blocking I2C Master transmission or reception.
status_t I2C_SlaveGetTransferStatus(const i2c_instance_t *const instance, uint32_t *bytesRemaining)
Return the current status of the I2C slave transfer.
status_t I2C_SlaveSendData(const i2c_instance_t *const instance, const uint8_t *txBuff, uint32_t txSize)
Perform a non-blocking send transaction on the I2C bus.
lpi2c_transfer_type_t transferType
status_t I2C_SlaveAbortTransfer(const i2c_instance_t *const instance)
Abort a non-blocking I2C slave transmission or reception.
status_t LPI2C_DRV_SlaveReceiveData(uint32_t instance, uint8_t *rxBuff, uint32_t rxSize)
Perform a non-blocking receive transaction on the I2C bus.
status_t FLEXIO_I2C_DRV_MasterInit(uint32_t instance, const flexio_i2c_master_user_config_t *userConfigPtr, flexio_i2c_master_state_t *master)
Initialize the FLEXIO_I2C master mode driver.
status_t LPI2C_DRV_SlaveSendDataBlocking(uint32_t instance, const uint8_t *txBuff, uint32_t txSize, uint32_t timeout)
Perform a blocking send transaction on the I2C bus.
status_t I2C_GetDefaultSlaveConfig(i2c_slave_t *config)
Gets the default configuration structure for slave.
i2c_master_callback_t callback
i2c_master_callback_t masterCallback
lpi2c_transfer_type_t transferType
lpi2c_mode_t
I2C operating modes Implements : lpi2c_mode_t_Class.
status_t I2C_SlaveReceiveDataBlocking(const i2c_instance_t *const instance, uint8_t *rxBuff, uint32_t rxSize, uint32_t timeout)
Perform a blocking receive transaction on the I2C bus.
status_t I2C_SlaveSendDataBlocking(const i2c_instance_t *const instance, const uint8_t *txBuff, uint32_t txSize, uint32_t timeout)
Perform a blocking send transaction on the I2C bus.
status_t I2C_MasterSendData(const i2c_instance_t *const instance, const uint8_t *txBuff, uint32_t txSize, bool sendStop)
Perform a non-blocking send transaction on the I2C bus.
void LPI2C_DRV_MasterSetSlaveAddr(uint32_t instance, const uint16_t address, const bool is10bitAddr)
Set the slave address for any subsequent I2C communication.
status_t FLEXIO_I2C_DRV_MasterGetBaudRate(flexio_i2c_master_state_t *master, uint32_t *baudRate)
Get the currently configured baud rate.
status_t LPI2C_DRV_SlaveSetRxBuffer(uint32_t instance, uint8_t *rxBuff, uint32_t rxSize)
Provide a buffer for receiving data.
Defines the configuration structure for I2C slave Implements: i2c_slave_t_Class.
flexio_driver_type_t driverType
void LPI2C_DRV_MasterGetBaudRate(uint32_t instance, lpi2c_baud_rate_params_t *baudRate)
Get the currently configured baud rate.
status_t LPI2C_DRV_MasterReceiveDataBlocking(uint32_t instance, uint8_t *rxBuff, uint32_t rxSize, bool sendStop, uint32_t timeout)
Perform a blocking receive transaction on the I2C bus.
status_t LPI2C_DRV_MasterSendData(uint32_t instance, const uint8_t *txBuff, uint32_t txSize, bool sendStop)
Perform a non-blocking send transaction on the I2C bus.
status_t LPI2C_DRV_SlaveSetTxBuffer(uint32_t instance, const uint8_t *txBuff, uint32_t txSize)
Provide a buffer for transmitting data.
status_t I2C_SlaveSetRxBuffer(const i2c_instance_t *const instance, uint8_t *rxBuff, uint32_t rxSize)
Provide a buffer for receiving data.
Slave configuration structure.
Slave internal context structure.
lpi2c_transfer_type_t
Type of LPI2C transfer (based on interrupts or DMA). Implements : lpi2c_transfer_type_t_Class.
status_t LPI2C_DRV_SlaveSendData(uint32_t instance, const uint8_t *txBuff, uint32_t txSize)
Perform a non-blocking send transaction on the I2C bus.
status_t LPI2C_DRV_SlaveAbortTransferData(uint32_t instance)
Abort a non-blocking I2C Master transmission or reception.
status_t I2C_MasterSendDataBlocking(const i2c_instance_t *const instance, const uint8_t *txBuff, uint32_t txSize, bool sendStop, uint32_t timeout)
Perform a blocking send transaction on the I2C bus.
status_t I2C_MasterInit(const i2c_instance_t *const instance, const i2c_master_t *config)
Initializes the I2C module in master mode.
status_t FLEXIO_I2C_DRV_MasterSetSlaveAddr(flexio_i2c_master_state_t *master, const uint16_t address)
Set the slave address for any subsequent I2C communication.
status_t
Status return codes. Common error codes will be a unified enumeration (C enum) that will contain all ...
status_t LPI2C_DRV_MasterInit(uint32_t instance, const lpi2c_master_user_config_t *userConfigPtr, lpi2c_master_state_t *master)
Initialize the LPI2C master mode driver.
status_t I2C_MasterGetTransferStatus(const i2c_instance_t *const instance, uint32_t *bytesRemaining)
Return the current status of the I2C master transfer.
i2c_pal_transfer_type_t transferType
Structure storing PAL instance information.
status_t LPI2C_DRV_MasterDeinit(uint32_t instance)
De-initialize the LPI2C master mode driver.
status_t FLEXIO_I2C_DRV_MasterDeinit(flexio_i2c_master_state_t *master)
De-initialize the FLEXIO_I2C master mode driver.
status_t I2C_GetDefaultMasterConfig(i2c_master_t *config)
Gets the default configuration structure for master.
status_t I2C_MasterSetSlaveAddress(const i2c_instance_t *const instance, const uint16_t address, const bool is10bitAddr)
Set the slave address for the I2C communication.
Defines the example structure.
i2c_operating_mode_t operatingMode
status_t I2C_MasterReceiveDataBlocking(const i2c_instance_t *const instance, uint8_t *rxBuff, uint32_t rxSize, bool sendStop, uint32_t timeout)
Perform a blocking receive transaction on the I2C bus.
Defines the configuration structure for I2C master Implements : i2c_master_t_Class.
i2c_slave_callback_t callback
status_t FLEXIO_I2C_DRV_MasterSetBaudRate(flexio_i2c_master_state_t *master, uint32_t baudRate)
Set the baud rate for any subsequent I2C communication.
status_t LPI2C_DRV_SlaveDeinit(uint32_t instance)
De-initialize the I2C slave mode driver.
status_t I2C_MasterGetBaudRate(const i2c_instance_t *const instance, uint32_t *baudRate)
Get the master baud rate for the I2C communication.
status_t I2C_SlaveSetTxBuffer(const i2c_instance_t *const instance, const uint8_t *txBuff, uint32_t txSize)
Provide a buffer for transmitting data.
status_t I2C_SlaveDeinit(const i2c_instance_t *const instance)
De-initializes the i2c slave module.
status_t I2C_MasterReceiveData(const i2c_instance_t *const instance, uint8_t *rxBuff, uint32_t rxSize, bool sendStop)
Perform a non-blocking receive transaction on the I2C bus.
Master internal context structure.
void LPI2C_DRV_MasterSetBaudRate(uint32_t instance, const lpi2c_mode_t operatingMode, const lpi2c_baud_rate_params_t baudRate)
Set the baud rate for any subsequent I2C communication.
Master configuration structure.
status_t FLEXIO_I2C_DRV_MasterSendDataBlocking(flexio_i2c_master_state_t *master, const uint8_t *txBuff, uint32_t txSize, bool sendStop, uint32_t timeout)
Perform a blocking send transaction on the I2C bus.
Master internal context structure.
status_t LPI2C_DRV_MasterReceiveData(uint32_t instance, uint8_t *rxBuff, uint32_t rxSize, bool sendStop)
Perform a non-blocking receive transaction on the I2C bus.
status_t FLEXIO_I2C_DRV_MasterReceiveDataBlocking(flexio_i2c_master_state_t *master, uint8_t *rxBuff, uint32_t rxSize, bool sendStop, uint32_t timeout)
Perform a blocking receive transaction on the I2C bus.
status_t I2C_SlaveInit(const i2c_instance_t *const instance, const i2c_slave_t *config)
Initializes the I2C module in slave mode.
status_t FLEXIO_I2C_DRV_MasterTransferAbort(flexio_i2c_master_state_t *master)
Aborts a non-blocking I2C master transaction.
status_t I2C_MasterSetBaudRate(const i2c_instance_t *const instance, const i2c_master_t *config, uint32_t baudRate)
Set the master baud rate for the I2C communication.
status_t I2C_MasterDeinit(const i2c_instance_t *const instance)
De-initializes the I2C master module.
status_t FLEXIO_I2C_DRV_MasterReceiveData(flexio_i2c_master_state_t *master, uint8_t *rxBuff, uint32_t rxSize, bool sendStop)
Perform a non-blocking receive transaction on the I2C bus.
status_t FLEXIO_I2C_DRV_MasterGetStatus(flexio_i2c_master_state_t *master, uint32_t *bytesRemaining)
Get the status of the current non-blocking I2C master transaction.
Defines the extension structure for the I2C over FLEXIO Implements : extension_flexio_for_i2c_t_Class...
status_t FLEXIO_DRV_InitDevice(uint32_t instance, flexio_device_state_t *deviceState)
Initializes the FlexIO device.
status_t LPI2C_DRV_SlaveReceiveDataBlocking(uint32_t instance, uint8_t *rxBuff, uint32_t rxSize, uint32_t timeout)
Perform a blocking receive transaction on the I2C bus.
status_t FLEXIO_I2C_DRV_MasterSendData(flexio_i2c_master_state_t *master, const uint8_t *txBuff, uint32_t txSize, bool sendStop)
Perform a non-blocking send transaction on the I2C bus.
status_t LPI2C_DRV_SlaveInit(uint32_t instance, const lpi2c_slave_user_config_t *userConfigPtr, lpi2c_slave_state_t *slave)
Initialize the I2C slave mode driver.
status_t LPI2C_DRV_MasterSendDataBlocking(uint32_t instance, const uint8_t *txBuff, uint32_t txSize, bool sendStop, uint32_t timeout)
Perform a blocking send transaction on the I2C bus.
i2c_slave_callback_t slaveCallback
i2c_pal_transfer_type_t transferType