i2c_pal.c
Go to the documentation of this file.
1 /*
2  * Copyright 2017 NXP
3  * All rights reserved.
4  *
5  * THIS SOFTWARE IS PROVIDED BY NXP "AS IS" AND ANY EXPRESSED OR
6  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
7  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
8  * IN NO EVENT SHALL NXP OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
9  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
10  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
11  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
12  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
13  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
14  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
15  * THE POSSIBILITY OF SUCH DAMAGE.
16  */
17 
79 #include "i2c_pal.h"
80 #include "device_registers.h"
81 
82 /* Include PD files */
83 #if (defined (I2C_OVER_LPI2C))
84  #include "lpi2c_driver.h"
85 #endif
86 
87 #if (defined (I2C_OVER_FLEXIO))
88  #include "flexio.h"
89  #include "flexio_i2c_driver.h"
90 #endif
91 
92 #if (defined (I2C_OVER_I2C))
93  #include "i2c_driver.h"
94 #endif
95 
96 #if (defined (I2C_OVER_SWI2C))
97  #include "swi2c_driver.h"
98 #endif
99 
100 /* Define state structures for LPI2C */
101 #if (defined(I2C_OVER_LPI2C))
102 
103  static lpi2c_master_state_t Lpi2cMasterState[NO_OF_LPI2C_INSTS_FOR_I2C];
104  static lpi2c_slave_state_t Lpi2cSlaveState[NO_OF_LPI2C_INSTS_FOR_I2C];
106  static uint32_t Lpi2cStateInstanceMapping[NO_OF_LPI2C_INSTS_FOR_I2C];
108  static bool Lpi2cStateIsAllocated[NO_OF_LPI2C_INSTS_FOR_I2C];
109 #endif
110 
111 /* Define state structure for FLEXIO */
112 #if (defined(I2C_OVER_FLEXIO))
113 
114  static flexio_i2c_master_state_t FlexioI2CState[NO_OF_FLEXIO_INSTS_FOR_I2C];
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];
120 #endif
121 
122 /* Define state structure for I2C */
123 #if (defined(I2C_OVER_I2C))
124 
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];
131 #endif
132 
133 /* Define state structure for SWI2C */
134 #if (defined(I2C_OVER_SWI2C))
135 
136  swi2c_master_state_t SWI2CMasterState[NO_OF_SWI2C_INSTS_FOR_I2C];
137 #endif
138 
139 #if defined(I2C_OVER_I2C) || defined(I2C_OVER_LPI2C) || defined (I2C_OVER_FLEXIO)
140 /*FUNCTION**********************************************************************
141 *
142 * Function Name : I2CAllocateState
143 * Description : Allocates one of the available state structure.
144 *
145 *END**************************************************************************/
146 static uint8_t I2CAllocateState(bool* isAllocated, uint32_t* instanceMapping, const i2c_instance_t * const instance, uint8_t numberOfinstances)
147 {
148  uint8_t i;
149  /* Allocate one of the I2C state structure for this instance */
150  for (i = 0;i < numberOfinstances;i++)
151  {
152  if (isAllocated[i] == false)
153  {
154  instanceMapping[i] = instance->instIdx;
155  isAllocated[i] = true;
156  break;
157  }
158  }
159 
160  return i;
161 }
162 #endif
163 
164 #if defined(I2C_OVER_I2C) || defined(I2C_OVER_LPI2C) || defined (I2C_OVER_FLEXIO)
165 /*FUNCTION**********************************************************************
166  *
167  * Function Name : I2CFreeState
168  * Description : Deallocates one of the available state structure.
169  *
170  *END**************************************************************************/
171 static void I2CFreeState(bool* isAllocated, const uint32_t* instanceMapping, const i2c_instance_t * const instance, uint8_t numberOfinstances)
172 {
173  uint8_t i;
174  /* Deallocate one of the available state structure*/
175  for (i = 0;i < numberOfinstances;i++)
176  {
177  if (instanceMapping[i] == instance->instIdx)
178  {
179  isAllocated[i] = false;
180  break;
181  }
182  }
183 }
184 #endif
185 
186 #if (defined(I2C_OVER_FLEXIO))
187 /*FUNCTION**********************************************************************
188  *
189  * Function Name : FindFlexioState
190  * Description : Search the state structure of the flexio instance
191  *
192  *END**************************************************************************/
193 static uint8_t FindFlexioState(const i2c_instance_t * const instance)
194 {
195  uint8_t i;
196  for (i = 0;i<NO_OF_FLEXIO_INSTS_FOR_I2C;i++)
197  {
198  if (FlexioI2CStateInstanceMapping[i] == instance->instIdx)
199  {
200  break;
201  }
202  }
203  return i;
204 }
205 #endif
206 
207 /*FUNCTION**********************************************************************
208  *
209  * Function Name : I2C_MasterInit
210  * Description : Configures the I2C in master mode
211  * Implements : I2C_MasterInit_Activity
212  *END**************************************************************************/
213 status_t I2C_MasterInit(const i2c_instance_t * const instance, const i2c_master_t *config)
214 {
215  status_t status = STATUS_ERROR;
216  uint8_t index = 0;
217 
218  /* Define I2C PAL over I2C */
219  #if (defined (I2C_OVER_LPI2C))
220  if(instance->instType == I2C_INST_TYPE_LPI2C)
221  {
222  lpi2c_master_user_config_t lpi2cConfig;
223  lpi2cConfig.slaveAddress = config->slaveAddress;
224  lpi2cConfig.is10bitAddr = config->is10bitAddr;
225  switch(config->transferType)
226  {
227  case I2C_PAL_USING_DMA: lpi2cConfig.transferType = LPI2C_USING_DMA; break;
229  default:
230  /* Transfer type not available for PAL */
231  break;
232  }
233  lpi2cConfig.masterCallback = config->callback;
234  lpi2cConfig.callbackParam = config->callbackParam;
235 
236  switch(config->operatingMode)
237  {
238  case I2C_PAL_STANDARD_MODE: lpi2cConfig.operatingMode = LPI2C_STANDARD_MODE; break;
239  case I2C_PAL_FAST_MODE: lpi2cConfig.operatingMode = LPI2C_FAST_MODE; break;
241  #if (LPI2C_HAS_FAST_PLUS_MODE)
242  lpi2cConfig.operatingMode = LPI2C_FASTPLUS_MODE;
243  #else
244  lpi2cConfig.operatingMode = LPI2C_STANDARD_MODE;
245  #endif
246  break;
248  #if (LPI2C_HAS_HIGH_SPEED_MODE)
249  lpi2cConfig.operatingMode = LPI2C_HIGHSPEED_MODE;
250  #else
251  lpi2cConfig.operatingMode = LPI2C_STANDARD_MODE;
252  #endif
253  break;
255  #if (LPI2C_HAS_ULTRA_FAST_MODE)
256  lpi2cConfig.operatingMode = LPI2C_ULTRAFAST_MODE;
257  #else
258  lpi2cConfig.operatingMode = LPI2C_STANDARD_MODE;
259  #endif
260  break;
261  default:
262  /* Operating mode not available for PAL */
263  break;
264  }
265 
266  lpi2cConfig.baudRate = config->baudRate;
267  /* DMA channel */
268  lpi2cConfig.dmaChannel = config->dmaChannel1;
269  /* Allocate one of the LPI2C state structure for this instance */
270  index = I2CAllocateState(Lpi2cStateIsAllocated, Lpi2cStateInstanceMapping, instance, NO_OF_LPI2C_INSTS_FOR_I2C);
271  status = LPI2C_DRV_MasterInit((uint32_t)instance->instIdx, &lpi2cConfig, &Lpi2cMasterState[index]);
272  }
273  #endif
274 
275  #if(defined (I2C_OVER_I2C))
276  if(instance->instType == I2C_INST_TYPE_I2C)
277  {
278  i2c_master_user_config_t i2cConfig;
279  i2cConfig.slaveAddress = config->slaveAddress;
280  switch(config->transferType)
281  {
282  case I2C_PAL_USING_DMA: i2cConfig.transferType = I2C_USING_DMA; break;
283  case I2C_PAL_USING_INTERRUPTS : i2cConfig.transferType = I2C_USING_INTERRUPTS; break;
284  default:
285  /* Transfer type not available for PAL */
286  break;
287  }
288  i2cConfig.masterCallback = config->callback;
289  i2cConfig.callbackParam = (uint8_t *)instance->instIdx;
290  i2cConfig.dmaChannel = config->dmaChannel1;
291  i2cConfig.baudRate = config->baudRate;
292  /*Allocate one of the I2C state structure for this instance */
293  index = I2CAllocateState(I2CStateIsAllocated, I2CStateInstanceMapping, instance, NO_OF_I2C_INSTS_FOR_I2C);
294  status = I2C_DRV_MasterInit((uint8_t)instance->instIdx, &i2cConfig, &I2CMasterState[index]);
295  }
296  #endif
297 
298 #if (defined(I2C_OVER_SWI2C))
299  if(instance->instType == I2C_INST_TYPE_SWI2C)
300  {
301  swi2c_master_user_config_t swi2cConfig;
302  swi2cConfig.slaveAddress = config->slaveAddress;
303  swi2cConfig. baudRate = config->baudRate;
304 
305  /* Initialize pins */
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;
310 
311  status = SWI2C_DRV_MasterInit(&SWI2CMasterState[instance->instIdx], &swi2cConfig);
312 
313  /* Cast to avoid compiler warnings */
314  (void) index;
315  }
316 #endif
317 
318  #if(defined (I2C_OVER_FLEXIO))
319  if(instance->instType == I2C_INST_TYPE_FLEXIO)
320  {
321  flexio_i2c_master_user_config_t flexioI2CConfig;
322  flexioI2CConfig.slaveAddress = config->slaveAddress;
323  switch(config->transferType)
324  {
325  case I2C_PAL_USING_DMA: flexioI2CConfig.driverType = FLEXIO_DRIVER_TYPE_DMA; break;
326  case I2C_PAL_USING_INTERRUPTS : flexioI2CConfig.driverType = FLEXIO_DRIVER_TYPE_INTERRUPTS; break;
327  default:
328  /* Transfer type not available for PAL */
329  break;
330  }
331  flexioI2CConfig.sdaPin = ((extension_flexio_for_i2c_t*)(config->extension))->sdaPin;
332  flexioI2CConfig.sclPin = ((extension_flexio_for_i2c_t*)(config->extension))->sclPin;
333  flexioI2CConfig.callback = config->callback;
334  flexioI2CConfig.callbackParam = config->callbackParam;
335  flexioI2CConfig.baudRate = config->baudRate;
336  flexioI2CConfig.rxDMAChannel = config -> dmaChannel2;
337  flexioI2CConfig.txDMAChannel = config -> dmaChannel1;
338  status = FLEXIO_DRV_InitDevice(0U, &FlexioState);
339 
340  if(status == STATUS_SUCCESS)
341  {
342  /* Allocate one of the Flexio state structure for this instance */
343  index = I2CAllocateState(FlexioI2CStateIsAllocated, FlexioI2CStateInstanceMapping, instance, NO_OF_FLEXIO_INSTS_FOR_I2C);
344  status = FLEXIO_I2C_DRV_MasterInit(0U, &flexioI2CConfig, (flexio_i2c_master_state_t*)&FlexioI2CState[index]);
345  }
346  }
347  #endif
348 
349  return status;
350 }
351 
352 /*FUNCTION**********************************************************************
353  *
354  * Function Name : I2C_SlaveInit
355  * Description : Configures the I2C in slave mode
356  * Implements : I2C_SlaveInit_Activity
357  *END**************************************************************************/
358 status_t I2C_SlaveInit(const i2c_instance_t * const instance, const i2c_slave_t *config)
359 {
360  status_t status = STATUS_ERROR;
361  uint8_t index = 0;
362 
363  /* Define I2C PAL over LPI2C */
364  #if (defined (I2C_OVER_LPI2C))
365  if(instance->instType == I2C_INST_TYPE_LPI2C)
366  {
367  lpi2c_slave_user_config_t lpi2cConfig;
368  lpi2cConfig.slaveAddress = config->slaveAddress;
369  lpi2cConfig.transferType = (lpi2c_transfer_type_t)config->transferType;
370  lpi2cConfig.dmaChannel = config->dmaChannel;
371  lpi2cConfig.is10bitAddr = config->is10bitAddr;
372  lpi2cConfig.slaveListening = config->slaveListening;
373  lpi2cConfig.slaveCallback = config->callback;
374  lpi2cConfig.callbackParam = config->callbackParam;
375  /*Allocate one of the LPI2C state structure for this instance */
376  index = I2CAllocateState(Lpi2cStateIsAllocated, Lpi2cStateInstanceMapping, instance, NO_OF_LPI2C_INSTS_FOR_I2C);
377  status = LPI2C_DRV_SlaveInit((uint32_t)instance->instIdx, &lpi2cConfig, &Lpi2cSlaveState[index]);
378  }
379  #endif
380 
381  /* Define I2C PAL over I2C */
382  #if (defined (I2C_OVER_I2C))
383  if(instance->instType == I2C_INST_TYPE_I2C)
384  {
385  i2c_slave_user_config_t i2cConfig;
386  i2cConfig.slaveAddress = config->slaveAddress;
387  i2cConfig.slaveListening = config->slaveListening;
388  i2cConfig.slaveCallback = config->callback;
389  i2cConfig.callbackParam = config->callbackParam;
390  /*Allocate one of the LPI2C state structure for this instance */
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]));
393  }
394  #endif
395 
396  /* Define I2C PAL over SWI2C */
397  #if (defined (I2C_OVER_SWI2C))
398  if(instance->instType == I2C_INST_TYPE_SWI2C)
399  {
400  status = STATUS_UNSUPPORTED;
401 
402  /* Cast to void compiler warnings */
403  (void) index;
404  (void) config;
405  }
406  #endif
407 
408  /* Define I2C PAL over FLEXIO */
409  #if (defined (I2C_OVER_FLEXIO))
410  if(instance->instType == I2C_INST_TYPE_FLEXIO)
411  {
412  /* Cast to void to avoid compiler warnings */
413  (void) config;
414  (void) index;
415  status = STATUS_UNSUPPORTED;
416  }
417  #endif
418 
419  return status;
420 }
421 
422 /*FUNCTION**********************************************************************
423  *
424  * Function Name : I2C_MasterSendData
425  * Description : Initializes a non-blocking master send data transfer
426  * Implements : I2C_MasterSendData_Activity
427  *
428  *END**************************************************************************/
429 status_t I2C_MasterSendData(const i2c_instance_t * const instance, const uint8_t *txBuff, uint32_t txSize, bool sendStop)
430 {
431  status_t status = STATUS_ERROR;
432 
433  /* Define I2C PAL over LPI2C */
434  #if defined (I2C_OVER_LPI2C)
435  if(instance->instType == I2C_INST_TYPE_LPI2C)
436  {
437  status = LPI2C_DRV_MasterSendData((uint32_t)instance->instIdx, txBuff, txSize, sendStop);
438  }
439  #endif
440 
441  /* Define I2C PAL over I2C */
442  #if defined (I2C_OVER_I2C)
443  if(instance->instType == I2C_INST_TYPE_I2C)
444  {
445  status = I2C_DRV_MasterSendData((uint8_t)instance->instIdx, txBuff, txSize, sendStop);
446  }
447  #endif
448 
449  /* Define I2C PAL over SWI2C */
450  #if defined(I2C_OVER_SWI2C)
451  if(instance->instType == I2C_INST_TYPE_SWI2C)
452  {
453  status = STATUS_UNSUPPORTED;
454 
455  /* Cast to avoid compiler warnings */
456  (void) txBuff;
457  (void) txSize;
458  (void) sendStop;
459 
460  }
461  #endif
462 
463  /* Define I2C PAL over FLEXIO */
464  #if defined (I2C_OVER_FLEXIO)
465  if(instance->instType == I2C_INST_TYPE_FLEXIO)
466  {
468  uint8_t instFlexio;
469 
470  instFlexio = FindFlexioState(instance);
471  master = &FlexioI2CState[instFlexio];
472  status = FLEXIO_I2C_DRV_MasterSendData(master, txBuff, txSize, sendStop);
473  }
474  #endif
475 
476  return status;
477 }
478 
479 /*FUNCTION**********************************************************************
480  *
481  * Function Name : I2C_MasterSendDataBlocking
482  * Description : Initializes a blocking master send data transfer with time-out
483  * Implements : I2C_MasterSendDataBlocking_Activity
484  *
485  *END**************************************************************************/
486 status_t I2C_MasterSendDataBlocking(const i2c_instance_t * const instance, const uint8_t *txBuff, uint32_t txSize, bool sendStop, uint32_t timeout)
487 {
488  status_t status = STATUS_ERROR;
489 
490  /* Define I2C PAL over LPI2C */
491  #if defined (I2C_OVER_LPI2C)
492  if(instance->instType == I2C_INST_TYPE_LPI2C)
493  {
494  status = LPI2C_DRV_MasterSendDataBlocking((uint32_t)instance->instIdx, txBuff, txSize, sendStop, timeout);
495  }
496  #endif
497 
498  /* Define I2C PAL over I2C */
499  #if defined (I2C_OVER_I2C)
500  if(instance->instType == I2C_INST_TYPE_I2C)
501  {
502  status = I2C_DRV_MasterSendDataBlocking((uint8_t)instance->instIdx, txBuff, txSize, sendStop, timeout);
503  }
504  #endif
505 
506  /* Define I2C PAL over SWI2C */
507  #if defined(I2C_OVER_SWI2C)
508  if(instance->instType == I2C_INST_TYPE_SWI2C)
509  {
510  status = SWI2C_DRV_MasterSendDataBlocking(&SWI2CMasterState[instance->instIdx], txBuff, txSize, sendStop);
511 
512  /* Cast to avoid compiler warnings */
513  (void) timeout;
514  }
515  #endif
516 
517  /* Define I2C PAL over FLEXIO */
518  #if defined (I2C_OVER_FLEXIO)
519  if(instance->instType == I2C_INST_TYPE_FLEXIO)
520  {
522  uint8_t instFlexio;
523 
524  instFlexio = FindFlexioState(instance);
525  master = &FlexioI2CState[instFlexio];
526  status = FLEXIO_I2C_DRV_MasterSendDataBlocking(master, txBuff, txSize, sendStop, timeout);
527  }
528  #endif
529 
530  return status;
531 }
532 
533 /*FUNCTION**********************************************************************
534  *
535  * Function Name : I2C_MasterReceiveData
536  * Description : Initializes a non-blocking master receive transfer
537  * Implements : I2C_MasterReceiveData_Activity
538  *
539  *END**************************************************************************/
540 status_t I2C_MasterReceiveData(const i2c_instance_t * const instance, uint8_t *rxBuff, uint32_t rxSize, bool sendStop)
541 {
542  status_t status = STATUS_ERROR;
543 
544  #if defined(I2C_OVER_LPI2C)
545  if(instance->instType == I2C_INST_TYPE_LPI2C)
546  {
547  status = LPI2C_DRV_MasterReceiveData((uint32_t)instance->instIdx, rxBuff, rxSize, sendStop);
548  }
549  #endif
550 
551  #if defined(I2C_OVER_I2C)
552  if(instance->instType == I2C_INST_TYPE_I2C)
553  {
554  status = I2C_DRV_MasterReceiveData((uint8_t)instance->instIdx, rxBuff, rxSize, sendStop);
555  }
556  #endif
557 
558  #if defined(I2C_OVER_SWI2C)
559  if(instance->instType == I2C_INST_TYPE_SWI2C)
560  {
561  status = STATUS_UNSUPPORTED;
562 
563  /* Cast to avoid compiler warnings */
564  (void) rxBuff;
565  (void) rxSize;
566  (void) sendStop;
567  }
568  #endif
569 
570  #if defined(I2C_OVER_FLEXIO)
571  if(instance->instType == I2C_INST_TYPE_FLEXIO)
572  {
574  uint8_t instFlexio;
575 
576  instFlexio = FindFlexioState(instance);
577  master = &FlexioI2CState[instFlexio];
578  status = FLEXIO_I2C_DRV_MasterReceiveData(master, rxBuff, rxSize, sendStop);
579  }
580  #endif
581 
582  return status;
583 }
584 
585 /*FUNCTION**********************************************************************
586  *
587  * Function Name : I2C_MasterReceiveDataBlocking
588  * Description : Initializes a blocking master receive transfer
589  * Implements : I2C_MasterReceiveDataBlocking_Activity
590  *
591  *END**************************************************************************/
592 status_t I2C_MasterReceiveDataBlocking(const i2c_instance_t * const instance, uint8_t *rxBuff, uint32_t rxSize, bool sendStop, uint32_t timeout)
593 {
594  status_t status = STATUS_ERROR;
595 
596  #if defined(I2C_OVER_LPI2C)
597  if(instance->instType == I2C_INST_TYPE_LPI2C)
598  {
599  status = LPI2C_DRV_MasterReceiveDataBlocking((uint32_t)instance->instIdx, rxBuff, rxSize, sendStop, timeout);
600  }
601  #endif
602 
603  #if defined(I2C_OVER_I2C)
604  if(instance->instType == I2C_INST_TYPE_I2C)
605  {
606  status = I2C_DRV_MasterReceiveDataBlocking((uint8_t)instance->instIdx, rxBuff, rxSize, sendStop, timeout);
607  }
608  #endif
609 
610  #if defined(I2C_OVER_SWI2C)
611  if(instance->instType == I2C_INST_TYPE_SWI2C)
612  {
613  status = SWI2C_DRV_MasterReceiveDataBlocking(&SWI2CMasterState[instance->instIdx], rxBuff, rxSize, sendStop);
614 
615  /* Cast to avoid compiler warnings */
616  (void) timeout;
617  }
618  #endif
619 
620  #if defined(I2C_OVER_FLEXIO)
621  if(instance->instType == I2C_INST_TYPE_FLEXIO)
622  {
624  uint32_t instFlexio;
625 
626  instFlexio = FindFlexioState(instance);
627  master = &FlexioI2CState[instFlexio];
628  status = FLEXIO_I2C_DRV_MasterReceiveDataBlocking(master, rxBuff, rxSize, sendStop, timeout);
629  }
630  #endif
631 
632  return status;
633 }
634 
635 /*FUNCTION**********************************************************************
636  *
637  * Function Name : I2C_MasterDeinit
638  * Description : De-initializes the i2c master module
639  * Implements : I2C_MasterDeinit_Activity
640  *
641  *END**************************************************************************/
642 status_t I2C_MasterDeinit(const i2c_instance_t * const instance)
643 {
644  status_t status = STATUS_ERROR;
645 
646  #if defined(I2C_OVER_LPI2C)
647  if(instance->instType == I2C_INST_TYPE_LPI2C)
648  {
649  status = LPI2C_DRV_MasterDeinit((uint32_t)instance->instIdx);
650  if (status == STATUS_SUCCESS)
651  {
652  I2CFreeState(Lpi2cStateIsAllocated, Lpi2cStateInstanceMapping, instance, NO_OF_LPI2C_INSTS_FOR_I2C);
653  }
654  }
655  #endif
656 
657  #if defined(I2C_OVER_I2C)
658  if(instance->instType == I2C_INST_TYPE_I2C)
659  {
660  status = I2C_DRV_MasterDeinit((uint8_t)instance->instIdx);
661  if (status == STATUS_SUCCESS)
662  {
663  I2CFreeState(I2CStateIsAllocated, I2CStateInstanceMapping, instance, NO_OF_I2C_INSTS_FOR_I2C);
664  }
665  }
666  #endif
667 
668  #if defined(I2C_OVER_SWI2C)
669  if(instance->instType == I2C_INST_TYPE_SWI2C)
670  {
671  status = STATUS_UNSUPPORTED;
672 
673  }
674  #endif
675 
676  #if defined(I2C_OVER_FLEXIO)
677  if(instance->instType == I2C_INST_TYPE_FLEXIO)
678  {
680  uint32_t instFlexio;
681 
682  instFlexio = FindFlexioState(instance);
683  master = &FlexioI2CState[instFlexio];
684  status = FLEXIO_I2C_DRV_MasterDeinit(master);
685  if (status == STATUS_SUCCESS)
686  {
687  I2CFreeState(FlexioI2CStateIsAllocated, FlexioI2CStateInstanceMapping, instance, NO_OF_FLEXIO_INSTS_FOR_I2C);
688  }
689  }
690  #endif
691 
692  return status;
693 }
694 
695 /*FUNCTION**********************************************************************
696  *
697  * Function Name : I2C_MasterSetSlaveAddress
698  * Description : set the slave address for any subsequent I2C communication
699  * Implements : I2C_MasterSetSlaveAddress_Activity
700  *
701  *END**************************************************************************/
702 status_t I2C_MasterSetSlaveAddress(const i2c_instance_t * const instance, const uint16_t address, const bool is10bitAddr)
703 {
704  status_t status = STATUS_ERROR;
705 
706  #if defined (I2C_OVER_LPI2C)
707  if(instance->instType == I2C_INST_TYPE_LPI2C)
708  {
709  (void) LPI2C_DRV_MasterSetSlaveAddr((uint32_t) instance->instIdx, address, is10bitAddr);
710  status = STATUS_SUCCESS;
711  }
712  #endif
713 
714  #if defined (I2C_OVER_I2C)
715  if(instance->instType == I2C_INST_TYPE_I2C)
716  {
717  (void) I2C_DRV_MasterSetSlaveAddress((uint32_t) instance->instIdx, address);
718  status = STATUS_SUCCESS;
719  }
720  #endif
721 
722  #if defined(I2C_OVER_SWI2C)
723  if(instance->instType == I2C_INST_TYPE_SWI2C)
724  {
725  (void) SWI2C_DRV_MasterSetSlaveAddress(&SWI2CMasterState[instance->instIdx], address);
726  status = STATUS_SUCCESS;
727  }
728  #endif
729 
730  #if defined (I2C_OVER_FLEXIO)
731  if (instance->instType == I2C_INST_TYPE_FLEXIO)
732  {
734  uint32_t instFlexio;
735 
736  instFlexio = FindFlexioState(instance);
737  master = &FlexioI2CState[instFlexio];
738  status = FLEXIO_I2C_DRV_MasterSetSlaveAddr(master, address);
739  }
740  #endif
741 
742  /* Cast to void to avoid compiler warnings for the cases where is10bitAddr is not used */
743  (void) is10bitAddr;
744 
745  return status;
746 }
747 
748 /*FUNCTION**********************************************************************
749  *
750  * Function Name : I2C_DRV_MasterSetBaudRate
751  * Description : set the baud rate for any subsequent I2C communication
752  * Implements : I2C_MasterSetBaudRate_Activity
753  *
754  *END**************************************************************************/
755 status_t I2C_MasterSetBaudRate(const i2c_instance_t * const instance, const i2c_master_t *config, uint32_t baudRate)
756 {
757  status_t status = STATUS_ERROR;
758  uint32_t counter = 0U;
759 
760  #if defined(I2C_OVER_LPI2C)
761  if(instance->instType == I2C_INST_TYPE_LPI2C)
762  {
763  lpi2c_baud_rate_params_t baudrateLpi2c;
764 
765  baudrateLpi2c.baudRate = baudRate;
766  (void)LPI2C_DRV_MasterSetBaudRate((uint32_t)instance->instIdx, (lpi2c_mode_t) config->operatingMode, baudrateLpi2c);
767  status = STATUS_SUCCESS;
768  }
769  #endif
770 
771  #if defined(I2C_OVER_I2C)
772  if(instance -> instType == I2C_INST_TYPE_I2C)
773  {
774  status = I2C_DRV_MasterSetBaudRate((uint32_t)instance->instIdx, baudRate);
775  }
776  #endif
777 
778  #if defined(I2C_OVER_SWI2C)
779  if(instance->instType == I2C_INST_TYPE_SWI2C)
780  {
781  /* SWI2C MAX baudRate is 20KHz*/
782  if(baudRate >= 20000U)
783  {
784  counter = 0U;
785  }
786 
787  /* BaudRate smaller that 100 Hz*/
788  if(baudRate <= 100U)
789  {
790  counter = 30000U;
791  }
792 
793  /* Calculate SCL waiting cycles */
794  if((baudRate < 20000U) && (baudRate > 100U))
795  {
796  counter = (uint32_t)((1000000U/baudRate) - 50U)*(3U/2U);
797  }
798 
799 
800  (void) SWI2C_DRV_SetWaitTimeForSCLTransition(&SWI2CMasterState[instance->instIdx], counter);
801  status = STATUS_SUCCESS;
802  }
803  #endif
804 
805  #if defined(I2C_OVER_FLEXIO)
806  if(instance->instType == I2C_INST_TYPE_FLEXIO)
807  {
808  flexio_i2c_master_state_t *masterFlexio;
809  uint32_t instFlexio;
810 
811  /* Cast to void to avoid compiler warnings */
812  (void) config;
813 
814  instFlexio = FindFlexioState(instance);
815  masterFlexio = &FlexioI2CState[instFlexio];
816  status = FLEXIO_I2C_DRV_MasterSetBaudRate(masterFlexio, baudRate);
817  }
818  #endif
819 
820  /* Cast to void to avoid compiler warnings */
821  (void) config;
822  (void) counter;
823 
824  return status;
825 }
826 
827 /*FUNCTION**********************************************************************
828  *
829  * Function Name : I2C_DRV_MasterGetBaudRate
830  * Description : get the baud rate for any subsequent I2C communication
831  * Implements : I2C_MasterGetBaudRate_Activity
832  *
833  *END**************************************************************************/
834 status_t I2C_MasterGetBaudRate(const i2c_instance_t * const instance, uint32_t *baudRate)
835 {
836  status_t status = STATUS_ERROR;
837 
838  #if defined (I2C_OVER_LPI2C)
839  if (instance->instType == I2C_INST_TYPE_LPI2C)
840  {
841  lpi2c_baud_rate_params_t baudrateLpi2c;
842 
843  (void) LPI2C_DRV_MasterGetBaudRate((uint32_t)instance->instIdx, &baudrateLpi2c);
844  *baudRate = baudrateLpi2c.baudRate;
845  status = STATUS_SUCCESS;
846  }
847  #endif
848 
849  #if defined(I2C_OVER_I2C)
850  if (instance->instType == I2C_INST_TYPE_I2C)
851  {
852  *baudRate = I2C_DRV_MasterGetBaudRate((uint32_t)instance->instIdx);
853  status = STATUS_SUCCESS;
854  }
855  #endif
856 
857  #if defined(I2C_OVER_SWI2C)
858  if(instance->instType == I2C_INST_TYPE_SWI2C)
859  {
860  status = STATUS_UNSUPPORTED;
861 
862  /* Cast to avoid compiler warnings */
863  (void) baudRate;
864  }
865  #endif
866 
867  #if defined(I2C_OVER_FLEXIO)
868  if (instance->instType == I2C_INST_TYPE_FLEXIO)
869  {
871  uint32_t instFlexio;
872 
873  instFlexio = FindFlexioState(instance);
874  master = &FlexioI2CState[instFlexio];
875  status = FLEXIO_I2C_DRV_MasterGetBaudRate(master, baudRate);
876  }
877  #endif
878 
879  return status;
880 }
881 
882 /*FUNCTION**********************************************************************
883  *
884  * Function Name : I2C_GetDefaultMasterConfig
885  * Description : Gets the default configuration structure for master
886  * Implements : I2C_GetDefaultMasterConfig_Activity
887  *
888  *END**************************************************************************/
890 {
891  config->slaveAddress = 32U;
892  config->is10bitAddr = false;
893 
894 #if defined(I2C_OVER_SWI2C)
895  config->baudRate = 0U;
896 #else
897  config->baudRate = 100000U;
898 #endif
899 
902  config->callback = NULL;
903  config->callbackParam = NULL;
904  config->extension = NULL;
905 
906  return STATUS_SUCCESS;
907 }
908 
909 /*FUNCTION**********************************************************************
910  *
911  * Function Name : I2C_GetDefaultSlaveConfig
912  * Description : Gets the default configuration structure for slave
913  * Implements : I2C_GetDefaultSlaveConfig_Activity
914  *
915  *END**************************************************************************/
917 {
918  config->slaveAddress = 32U;
919  config->is10bitAddr = false;
920  config->slaveListening = true;
922  config->callback = NULL;
923  config->callbackParam = NULL;
924 
925  return STATUS_SUCCESS;
926 }
927 /*FUNCTION**********************************************************************
928  *
929  * Function Name : I2C_SlaveSendData
930  * Description : Initializes a non-blocking master transfer
931  * Implements : I2C_SlaveSendData_Activity
932  *
933  *END**************************************************************************/
934 status_t I2C_SlaveSendData(const i2c_instance_t * const instance, const uint8_t *txBuff, uint32_t txSize)
935 {
936  status_t status = STATUS_ERROR;
937 
938  #if defined(I2C_OVER_LPI2C)
939  if(instance->instType == I2C_INST_TYPE_LPI2C)
940  {
941  status = LPI2C_DRV_SlaveSendData((uint32_t)instance->instIdx, txBuff, txSize);
942  }
943  #endif
944 
945  #if defined(I2C_OVER_I2C)
946  if(instance->instType == I2C_INST_TYPE_I2C)
947  {
948  status = I2C_DRV_SlaveSendData((uint8_t)instance->instIdx, txBuff, txSize);
949  }
950  #endif
951 
952  #if defined(I2C_OVER_SWI2C)
953  if(instance->instType == I2C_INST_TYPE_SWI2C)
954  {
955  status = STATUS_UNSUPPORTED;
956 
957  /* Cast to avoid compiler warnings */
958  (void) txBuff;
959  (void) txSize;
960  }
961  #endif
962 
963  #if defined(I2C_OVER_FLEXIO)
964  if(instance->instType == I2C_INST_TYPE_FLEXIO)
965  {
966  /* Cast to void to avoid compiler warnings for the unused parameters */
967  (void) txBuff;
968  (void) txSize;
969  status = STATUS_UNSUPPORTED;
970  }
971  #endif
972 
973  return status;
974 }
975 
976 /*FUNCTION**********************************************************************
977  *
978  * Function Name : I2C_SlaveSendDataBlocking
979  * Description : perform a blocking receive transaction on the I2C bus
980  * Implements : I2C_SlaveSendDataBlocking_Activity
981  *
982  *END**************************************************************************/
983 status_t I2C_SlaveSendDataBlocking(const i2c_instance_t * const instance, const uint8_t *txBuff, uint32_t txSize, uint32_t timeout)
984 {
985  status_t status = STATUS_ERROR;
986 
987  #if defined(I2C_OVER_LPI2C)
988  if(instance->instType == I2C_INST_TYPE_LPI2C)
989  {
990  status = LPI2C_DRV_SlaveSendDataBlocking((uint32_t)instance->instIdx, txBuff, txSize, timeout);
991  }
992  #endif
993 
994  #if defined(I2C_OVER_I2C)
995  if(instance->instType == I2C_INST_TYPE_I2C)
996  {
997  status = I2C_DRV_SlaveSendDataBlocking((uint8_t)instance->instIdx, txBuff, txSize, timeout);
998  }
999  #endif
1000 
1001  #if defined(I2C_OVER_SWI2C)
1002  if(instance->instType == I2C_INST_TYPE_SWI2C)
1003  {
1004  /* Cast to void to avoid compiler warnings for the unused parameter */
1005  (void) txBuff;
1006  (void) txSize;
1007  (void) timeout;
1008 
1009  status = STATUS_UNSUPPORTED;
1010  }
1011  #endif
1012 
1013  #if defined(I2C_OVER_FLEXIO)
1014  if(instance->instType == I2C_INST_TYPE_FLEXIO)
1015  {
1016  /* Cast to void to avoid compiler warnings for the unused parameter */
1017  (void) txBuff;
1018  (void) txSize;
1019  (void) timeout;
1020  status = STATUS_UNSUPPORTED;
1021  }
1022  #endif
1023 
1024  return status;
1025 }
1026 
1027 /*FUNCTION**********************************************************************
1028  *
1029  * Function Name : I2C_SlaveReceiveData
1030  * Description : perform a non-blocking receive transaction on the I2C bus
1031  * Implements : I2C_SlaveReceiveData_Activity
1032  *
1033  *END**************************************************************************/
1034 status_t I2C_SlaveReceiveData(const i2c_instance_t * const instance, uint8_t *rxBuff, uint32_t rxSize)
1035 {
1036  status_t status = STATUS_ERROR;
1037 
1038  #if defined(I2C_OVER_LPI2C)
1039  if(instance->instType == I2C_INST_TYPE_LPI2C)
1040  {
1041  status = LPI2C_DRV_SlaveReceiveData((uint32_t)instance->instIdx, rxBuff, rxSize);
1042  }
1043  #endif
1044 
1045  #if defined(I2C_OVER_I2C)
1046  if(instance->instType == I2C_INST_TYPE_I2C)
1047  {
1048  status = I2C_DRV_SlaveReceiveData((uint8_t)instance->instIdx, rxBuff, rxSize);
1049  }
1050  #endif
1051 
1052  #if defined(I2C_OVER_SWI2C)
1053  if(instance->instType == I2C_INST_TYPE_SWI2C)
1054  {
1055  /* Cast to avoid compiler warnings */
1056  (void) rxBuff;
1057  (void) rxSize;
1058 
1059  status = STATUS_UNSUPPORTED;
1060 
1061  }
1062  #endif
1063 
1064  #if defined(I2C_OVER_FLEXIO)
1065  if(instance->instType == I2C_INST_TYPE_FLEXIO)
1066  {
1067  /* Cast to void to avoid compiler warnings */
1068  (void) rxBuff;
1069  (void) rxSize;
1070  status = STATUS_UNSUPPORTED;
1071  }
1072  #endif
1073 
1074  return status;
1075 }
1076 
1077 /*FUNCTION**********************************************************************
1078  *
1079  * Function Name : I2C_SlaveReceiveDataBlocking
1080  * Description : perform a blocking receive transaction on the I2C bus
1081  * Implements : I2C_SlaveReceiveDataBlocking_Activity
1082  *
1083  *END**************************************************************************/
1084 status_t I2C_SlaveReceiveDataBlocking(const i2c_instance_t * const instance, uint8_t *rxBuff,
1085  uint32_t rxSize, uint32_t timeout)
1086 {
1087  status_t status = STATUS_ERROR;
1088 
1089  #if defined(I2C_OVER_LPI2C)
1090  if(instance->instType == I2C_INST_TYPE_LPI2C)
1091  {
1092  status = LPI2C_DRV_SlaveReceiveDataBlocking((uint32_t)instance->instIdx, rxBuff, rxSize, timeout);
1093  }
1094  #endif
1095 
1096  #if defined(I2C_OVER_I2C)
1097  if(instance->instType == I2C_INST_TYPE_I2C)
1098  {
1099  status = I2C_DRV_SlaveReceiveDataBlocking((uint8_t)instance->instIdx, rxBuff, rxSize, timeout);
1100  }
1101  #endif
1102 
1103  #if defined(I2C_OVER_SWI2C)
1104  if(instance->instType == I2C_INST_TYPE_SWI2C)
1105  {
1106  /* Cast to void to avoid compiler warnings */
1107  (void) rxBuff;
1108  (void) rxSize;
1109  (void) timeout;
1110 
1111  status = STATUS_UNSUPPORTED;
1112  }
1113  #endif
1114 
1115  #if defined(I2C_OVER_FLEXIO)
1116  if(instance->instType == I2C_INST_TYPE_FLEXIO)
1117  {
1118  /* Cast to void to avoid compiler warnings */
1119  (void) rxBuff;
1120  (void) rxSize;
1121  (void) timeout;
1122  status = STATUS_UNSUPPORTED;
1123  }
1124  #endif
1125 
1126  return status;
1127 }
1128 
1129 /*FUNCTION**********************************************************************
1130  *
1131  * Function Name : I2C_SlaveSetRxBuffer
1132  * Description : Provide a buffer for receiving data.
1133  *
1134  * Implements : I2C_SlaveSetRxBuffer_Activity
1135  *END***************************************************************************/
1136 status_t I2C_SlaveSetRxBuffer(const i2c_instance_t * const instance, uint8_t *rxBuff, uint32_t rxSize)
1137 {
1138  status_t status = STATUS_ERROR;
1139  #if defined(I2C_OVER_LPI2C)
1140  if(instance->instType == I2C_INST_TYPE_LPI2C)
1141  {
1142  status = LPI2C_DRV_SlaveSetRxBuffer(instance->instIdx, rxBuff, rxSize);
1143  }
1144  #endif
1145 
1146  #if defined(I2C_OVER_I2C)
1147  if(instance->instType == I2C_INST_TYPE_I2C)
1148  {
1149  status = I2C_DRV_SlaveSetRxBuffer((uint8_t) instance->instIdx, rxBuff, rxSize);
1150  }
1151  #endif
1152 
1153  #if defined(I2C_OVER_SWI2C)
1154  if(instance->instType == I2C_INST_TYPE_SWI2C)
1155  {
1156  /* Cast to void to avoid compiler warnings */
1157  (void) rxBuff;
1158  (void) rxSize;
1159 
1160  status = STATUS_UNSUPPORTED;
1161  }
1162  #endif
1163 
1164  #if defined(I2C_OVER_FLEXIO)
1165  if(instance->instType == I2C_INST_TYPE_FLEXIO)
1166  {
1167  /* Cast to void to avoid compiler warnings */
1168  (void) rxBuff;
1169  (void) rxSize;
1170  status = STATUS_UNSUPPORTED;
1171  }
1172  #endif
1173 
1174  return status;
1175 }
1176 
1177 /*FUNCTION**********************************************************************
1178  *
1179  * Function Name : I2C_SlaveSetTxBuffer
1180  * Description : Provide a buffer for transmitting data.
1181  *
1182  * Implements : I2C_SlaveSetTxBuffer_Activity
1183  *END***************************************************************************/
1184 status_t I2C_SlaveSetTxBuffer(const i2c_instance_t * const instance, const uint8_t *txBuff, uint32_t txSize)
1185 {
1186  status_t status = STATUS_ERROR;
1187 
1188  #if defined(I2C_OVER_LPI2C)
1189  if(instance->instType == I2C_INST_TYPE_LPI2C)
1190  {
1191  status = LPI2C_DRV_SlaveSetTxBuffer(instance->instIdx, txBuff, txSize);
1192  }
1193  #endif
1194 
1195  #if defined(I2C_OVER_I2C)
1196  if(instance->instType == I2C_INST_TYPE_I2C)
1197  {
1198  status = I2C_DRV_SlaveSetTxBuffer((uint8_t) instance->instIdx, txBuff, txSize);
1199  }
1200  #endif
1201 
1202  #if defined(I2C_OVER_SWI2C)
1203  if(instance->instType == I2C_INST_TYPE_SWI2C)
1204  {
1205  /* Cast to void to avoid compiler warnings */
1206  (void) txBuff;
1207  (void) txSize;
1208 
1209  status = STATUS_UNSUPPORTED;
1210  }
1211  #endif
1212 
1213 
1214  #if defined(I2C_OVER_FLEXIO)
1215  if(instance->instType == I2C_INST_TYPE_FLEXIO)
1216  {
1217  /* Cast to void to avoid compiler warnings */
1218  (void) txBuff;
1219  (void) txSize;
1220  status = STATUS_UNSUPPORTED;
1221  }
1222  #endif
1223 
1224  return status;
1225 }
1226 
1227 /*FUNCTION**********************************************************************
1228  *
1229  * Function Name : I2C_SlaveDeinit
1230  * Description : De-initializes the i2c slave module
1231  * Implements : I2C_SlaveDeinit_Activity
1232  *
1233  *END**************************************************************************/
1234 status_t I2C_SlaveDeinit(const i2c_instance_t * const instance)
1235 {
1236  status_t status = STATUS_ERROR;
1237 
1238  #if defined(I2C_OVER_LPI2C)
1239  if(instance->instType == I2C_INST_TYPE_LPI2C)
1240  {
1241  status = LPI2C_DRV_SlaveDeinit((uint32_t)instance->instIdx);
1242  if (status == STATUS_SUCCESS)
1243  {
1244  I2CFreeState(Lpi2cStateIsAllocated, Lpi2cStateInstanceMapping, instance, NO_OF_LPI2C_INSTS_FOR_I2C);
1245  }
1246  }
1247  #endif
1248 
1249  #if defined(I2C_OVER_I2C)
1250  if(instance->instType == I2C_INST_TYPE_I2C)
1251  {
1252  status = I2C_DRV_SlaveDeinit((uint8_t)instance->instIdx);
1253  if (status == STATUS_SUCCESS)
1254  {
1255  I2CFreeState(I2CStateIsAllocated, I2CStateInstanceMapping, instance, NO_OF_I2C_INSTS_FOR_I2C);
1256  }
1257  }
1258  #endif
1259 
1260  #if defined(I2C_OVER_SWI2C)
1261  if(instance->instType == I2C_INST_TYPE_SWI2C)
1262  {
1263  status = STATUS_UNSUPPORTED;
1264  }
1265  #endif
1266 
1267  #if defined(I2C_OVER_FLEXIO)
1268  if(instance->instType == I2C_INST_TYPE_FLEXIO)
1269  {
1270  status = STATUS_UNSUPPORTED;
1271  }
1272  #endif
1273 
1274  return status;
1275 }
1276 
1277 /*FUNCTION**********************************************************************
1278  *
1279  * Function Name : I2C_MasterGetTransferStatus
1280  * Description : Get the status of the current non-blocking I2C master transaction
1281  * Implements : I2C_MasterGetTransferStatus_Activity
1282  *END**************************************************************************/
1283 status_t I2C_MasterGetTransferStatus(const i2c_instance_t * const instance, uint32_t *bytesRemaining)
1284 {
1285  status_t status = STATUS_ERROR;
1286 
1287  /* Define I2C PAL over I2C */
1288  #if defined(I2C_OVER_LPI2C)
1289  if(instance->instType == I2C_INST_TYPE_LPI2C)
1290  {
1291  status = LPI2C_DRV_MasterGetTransferStatus(instance->instIdx, bytesRemaining);
1292  }
1293  #endif
1294 
1295  /* Define I2C PAL over FLEXIO */
1296  #if defined(I2C_OVER_FLEXIO)
1297  if(instance->instType == I2C_INST_TYPE_FLEXIO)
1298  {
1300  uint32_t instFlexio;
1301 
1302  instFlexio = FindFlexioState(instance);
1303  master = FlexioI2CState[instFlexio];
1304 
1305  status = FLEXIO_I2C_DRV_MasterGetStatus(&master, bytesRemaining);
1306  }
1307  #endif
1308 
1309  #if defined(I2C_OVER_SWI2C)
1310  if(instance->instType == I2C_INST_TYPE_SWI2C)
1311  {
1312  /* Cast to void to avoid compiler warnings */
1313  (void)bytesRemaining;
1314 
1315  status = STATUS_UNSUPPORTED;
1316  }
1317  #endif
1318 
1319  /* Define I2C PAL over LPI2C */
1320  #if defined(I2C_OVER_I2C)
1321  if(instance->instType == I2C_INST_TYPE_I2C)
1322  {
1323  status = I2C_DRV_MasterGetTransferStatus(instance->instIdx);
1324 
1325  /* Cast to void to avoid compiler warnings */
1326  (void)bytesRemaining;
1327  }
1328  #endif
1329 
1330  return status;
1331 }
1332 
1333 /*FUNCTION**********************************************************************
1334  *
1335  * Function Name : I2C_SlaveGetTransferStatus
1336  * Description : Get the status of the current non-blocking I2C slave transaction
1337  * Implements : I2C_SlaveGetTransferStatus_Activity
1338  *
1339  *END**************************************************************************/
1340 status_t I2C_SlaveGetTransferStatus(const i2c_instance_t * const instance, uint32_t *bytesRemaining)
1341 {
1342  status_t status = STATUS_ERROR;
1343 
1344  /* Define I2C PAL over I2C */
1345  #if defined(I2C_OVER_LPI2C)
1346  if(instance->instType == I2C_INST_TYPE_LPI2C)
1347  {
1348  status = LPI2C_DRV_SlaveGetTransferStatus(instance->instIdx, bytesRemaining);
1349  }
1350  #endif
1351 
1352  /* Define I2C PAL over FLEXIO */
1353  #if defined(I2C_OVER_FLEXIO)
1354  if(instance->instType == I2C_INST_TYPE_FLEXIO)
1355  {
1356  status = STATUS_UNSUPPORTED;
1357  }
1358  #endif
1359 
1360  /* Define I2C PAL over SWI2C */
1361  #if defined(I2C_OVER_SWI2C)
1362  if(instance->instType == I2C_INST_TYPE_SWI2C)
1363  {
1364  status = STATUS_UNSUPPORTED;
1365  }
1366  #endif
1367 
1368  /* Define I2C PAL over LPI2C */
1369  #if defined(I2C_OVER_I2C)
1370  if(instance->instType == I2C_INST_TYPE_I2C)
1371  {
1372  status = I2C_DRV_SlaveGetTransferStatus(instance->instIdx);
1373  }
1374  #endif
1375 
1376  (void) bytesRemaining;
1377 
1378  return status;
1379 }
1380 
1381 /*FUNCTION**********************************************************************
1382  *
1383  * Function Name : I2C_MasterAbortTransfer
1384  * Description : abort a non-blocking I2C Master transmission or reception
1385  * Implements : I2C_MasterAbortTransfer_Activity
1386  *
1387  *END**************************************************************************/
1389 {
1390  status_t status = STATUS_ERROR;
1391 
1392  /* Define I2C PAL over I2C */
1393  #if defined(I2C_OVER_LPI2C)
1394  if (instance->instType == I2C_INST_TYPE_LPI2C)
1395  {
1396  status = LPI2C_DRV_MasterAbortTransferData(instance->instIdx);
1397  }
1398  #endif
1399 
1400  /* Define I2C PAL over FLEXIO */
1401  #if defined(I2C_OVER_FLEXIO)
1402  if(instance->instType == I2C_INST_TYPE_FLEXIO)
1403  {
1404  flexio_i2c_master_state_t *master;
1405  uint32_t instFlexio;
1406 
1407  instFlexio = FindFlexioState(instance);
1408  master = &FlexioI2CState[instFlexio];
1409 
1410  status = FLEXIO_I2C_DRV_MasterTransferAbort(master);
1411  }
1412  #endif
1413 
1414  #if defined(I2C_OVER_SWI2C)
1415  if(instance->instType == I2C_INST_TYPE_SWI2C)
1416  {
1417  status = STATUS_UNSUPPORTED;
1418  }
1419 
1420  #endif
1421 
1422  /* Define I2C PAL over LPI2C */
1423  #if defined(I2C_OVER_I2C)
1424  if(instance->instType == I2C_INST_TYPE_I2C)
1425  {
1426  status = I2C_DRV_MasterAbortTransferData(instance->instIdx);
1427 
1428  }
1429  #endif
1430 
1431  return status;
1432 }
1433 
1434 /*FUNCTION**********************************************************************
1435  *
1436  * Function Name : I2C_SlaveAbortTransfer
1437  * Description : abort a non-blocking I2C slave transmission or reception
1438  * Implements : I2C_SlaveAbortTransfer_Activity
1439  *
1440  *END**************************************************************************/
1442 {
1443  status_t status = STATUS_ERROR;
1444 
1445  /* Define I2C PAL over I2C */
1446  #if defined(I2C_OVER_LPI2C)
1447  if (instance->instType == I2C_INST_TYPE_LPI2C)
1448  {
1449  status = LPI2C_DRV_SlaveAbortTransferData(instance->instIdx);
1450  }
1451  #endif
1452 
1453  /* Define I2C PAL over FLEXIO */
1454  #if defined(I2C_OVER_FLEXIO)
1455  if(instance->instType == I2C_INST_TYPE_FLEXIO)
1456  {
1457  status = STATUS_UNSUPPORTED;
1458  }
1459  #endif
1460 
1461  #if defined(I2C_OVER_SWI2C)
1462  if(instance->instType == I2C_INST_TYPE_SWI2C)
1463  {
1464  status = STATUS_UNSUPPORTED;
1465  }
1466  #endif
1467 
1468  /* Define I2C PAL over LPI2C */
1469  #if defined(I2C_OVER_I2C)
1470  if(instance->instType == I2C_INST_TYPE_I2C)
1471  {
1472  status = I2C_DRV_SlaveAbortTransferData(instance->instIdx);
1473  }
1474  #endif
1475 
1476  return status;
1477 }
1478 
1479 /*******************************************************************************
1480  * EOF
1481  ******************************************************************************/
status_t LPI2C_DRV_SlaveGetTransferStatus(uint32_t instance, uint32_t *bytesRemaining)
Return the current status of the I2C slave transfer.
void * callbackParam
Definition: i2c_pal.h:118
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.
Definition: i2c_pal.c:1034
status_t I2C_MasterAbortTransfer(const i2c_instance_t *const instance)
Abort a non-blocking I2C Master transmission or reception.
Definition: i2c_pal.c:1388
void * extension
Definition: i2c_pal.h:119
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.
Definition: i2c_pal.c:1340
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.
Definition: i2c_pal.c:934
lpi2c_transfer_type_t transferType
Definition: lpi2c_driver.h:124
status_t I2C_SlaveAbortTransfer(const i2c_instance_t *const instance)
Abort a non-blocking I2C slave transmission or reception.
Definition: i2c_pal.c:1441
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.
Definition: i2c_pal.c:916
void * callbackParam
Definition: i2c_pal.h:137
i2c_master_callback_t callback
Definition: i2c_pal.h:114
i2c_master_callback_t masterCallback
Definition: lpi2c_driver.h:126
lpi2c_transfer_type_t transferType
Definition: lpi2c_driver.h:145
lpi2c_mode_t
I2C operating modes Implements : lpi2c_mode_t_Class.
Definition: lpi2c_driver.h:74
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.
Definition: i2c_pal.c:1084
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.
Definition: i2c_pal.c:983
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.
Definition: i2c_pal.c:429
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.
Definition: i2c_pal.h:127
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.
Definition: i2c_pal.c:1136
Slave configuration structure.
Definition: lpi2c_driver.h:139
Slave internal context structure.
Definition: lpi2c_driver.h:238
Baud rate structure.
Definition: lpi2c_driver.h:161
lpi2c_transfer_type_t
Type of LPI2C transfer (based on interrupts or DMA). Implements : lpi2c_transfer_type_t_Class.
Definition: lpi2c_driver.h:92
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.
Definition: i2c_pal.c:486
i2c_inst_type_t instType
status_t I2C_MasterInit(const i2c_instance_t *const instance, const i2c_master_t *config)
Initializes the I2C module in master mode.
Definition: i2c_pal.c:213
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 ...
Definition: status.h:44
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.
Definition: i2c_pal.c:1283
i2c_pal_transfer_type_t transferType
Definition: i2c_pal.h:112
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.
Definition: i2c_pal.c:889
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.
Definition: i2c_pal.c:702
Defines the example structure.
Definition: lpi2c_driver.h:114
uint16_t slaveAddress
Definition: i2c_pal.h:106
i2c_operating_mode_t operatingMode
Definition: i2c_pal.h:113
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.
Definition: i2c_pal.c:592
Defines the configuration structure for I2C master Implements : i2c_master_t_Class.
Definition: i2c_pal.h:104
i2c_slave_callback_t callback
Definition: i2c_pal.h:136
status_t FLEXIO_I2C_DRV_MasterSetBaudRate(flexio_i2c_master_state_t *master, uint32_t baudRate)
Set the baud rate for any subsequent I2C communication.
uint8_t dmaChannel
Definition: i2c_pal.h:134
uint8_t dmaChannel1
Definition: i2c_pal.h:109
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.
Definition: i2c_pal.c:834
status_t I2C_SlaveSetTxBuffer(const i2c_instance_t *const instance, const uint8_t *txBuff, uint32_t txSize)
Provide a buffer for transmitting data.
Definition: i2c_pal.c:1184
status_t I2C_SlaveDeinit(const i2c_instance_t *const instance)
De-initializes the i2c slave module.
Definition: i2c_pal.c:1234
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.
Definition: i2c_pal.c:540
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.
uint32_t baudRate
Definition: i2c_pal.h:108
bool is10bitAddr
Definition: i2c_pal.h:130
bool is10bitAddr
Definition: i2c_pal.h:107
Master internal context structure.
Definition: lpi2c_driver.h:203
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.
Definition: i2c_pal.c:358
uint16_t slaveAddress
Definition: i2c_pal.h:129
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.
Definition: i2c_pal.c:755
status_t I2C_MasterDeinit(const i2c_instance_t *const instance)
De-initializes the I2C master module.
Definition: i2c_pal.c:642
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...
Definition: i2c_pal.h:65
status_t FLEXIO_DRV_InitDevice(uint32_t instance, flexio_device_state_t *deviceState)
Initializes the FlexIO device.
Definition: flexio_common.c:89
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
Definition: lpi2c_driver.h:147
bool slaveListening
Definition: i2c_pal.h:131
i2c_pal_transfer_type_t transferType
Definition: i2c_pal.h:133