S32 SDK
uart_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 
18 #include "uart_pal.h"
19 #include "device_registers.h"
20 
21 /* Include PD files */
22 #if (defined(UART_OVER_LPUART))
23  #include "lpuart_driver.h"
24 #endif
25 
26 #if (defined(UART_OVER_FLEXIO))
27  #include "flexio.h"
28  #include "flexio_uart_driver.h"
29 #endif
30 
31 #if (defined(UART_OVER_LINFLEXD))
32  #include "linflexd_uart_driver.h"
33 #endif
34 
35 /* Define state structures for LPUART */
36 #if (defined(UART_OVER_LPUART))
37 
38  lpuart_state_t * lpuartState[NO_OF_LPUART_INSTS_FOR_UART];
40  static uart_instance_t lpuartStateInstanceMapping[NO_OF_LPUART_INSTS_FOR_UART];
42  static bool lpuartStateIsAllocated[NO_OF_LPUART_INSTS_FOR_UART];
43 #endif
44 
45 /* Define state structures for UART over FLEXIO */
46 #if (defined(UART_OVER_FLEXIO))
47 
48  flexio_uart_state_t flexioUartTxState[NO_OF_FLEXIO_INSTS_FOR_UART];
50  flexio_uart_state_t flexioUartRxState[NO_OF_FLEXIO_INSTS_FOR_UART];
51  flexio_device_state_t flexioDeviceState;
53  static uart_instance_t flexioUartStateInstanceMapping[NO_OF_FLEXIO_INSTS_FOR_UART];
55  static bool flexioUartStateIsAllocated[NO_OF_FLEXIO_INSTS_FOR_UART];
56 #endif
57 
58 /* Define state structures for LinFlexD */
59 #if (defined(UART_OVER_LINFLEXD))
60 
61  linflexd_uart_state_t linFlexDState[NO_OF_LINFLEXD_INSTS_FOR_UART];
63  static uart_instance_t linFlexDStateInstanceMapping[NO_OF_LINFLEXD_INSTS_FOR_UART];
65  static bool linFlexDStateIsAllocated[NO_OF_LINFLEXD_INSTS_FOR_UART];
66 #endif
67 
68 /*FUNCTION**********************************************************************
69  *
70  * Function Name : UART_AllocateState
71  * Description : Allocates one of the available state structures.
72  *
73  *END**************************************************************************/
74 static uint8_t UART_AllocateState(bool* isAllocated,
75  uart_instance_t* instanceMapping,
76  uart_instance_t instance,
77  uint8_t numberOfinstances)
78 {
79  uint8_t i;
80  /* Allocate one of the UART state structures for this instance */
81  for (i = 0; i < numberOfinstances; i++)
82  {
83  if (isAllocated[i] == false)
84  {
85  instanceMapping[i] = instance;
86  isAllocated[i] = true;
87  break;
88  }
89  }
90  return i;
91 }
92 
93 /*FUNCTION**********************************************************************
94  *
95  * Function Name : UART_FreeState
96  * Description : Deallocates one of the available state structures.
97  *
98  *END**************************************************************************/
99 static void UART_FreeState(bool* isAllocated,
100  uart_instance_t* instanceMapping,
101  uart_instance_t instance,
102  uint8_t numberOfinstances)
103 {
104  uint8_t i;
105  /* Free one of the UART state structures for this instance */
106  for (i = 0;i < numberOfinstances;i++)
107  {
108  if (instanceMapping[i] == instance)
109  {
110  isAllocated[i] = false;
111  break;
112  }
113  }
114 }
115 
116 #if (defined(UART_OVER_FLEXIO))
117 /*FUNCTION**********************************************************************
118  *
119  * Function Name : UART_FindFlexioState
120  * Description : Search the state structure of the FlexIO instance
121  *
122  *END**************************************************************************/
123 static uint8_t UART_FindFlexioState(uart_instance_t instance)
124 {
125  uint8_t i;
126  for (i = 0; i < NO_OF_FLEXIO_INSTS_FOR_UART; i++)
127  {
128  if (flexioUartStateInstanceMapping[i] == instance)
129  {
130  break;
131  }
132  }
133  return i;
134 }
135 #endif
136 
137 /*FUNCTION**********************************************************************
138  *
139  * Function Name : UART_Init
140  * Description : Configures the UART module
141  *
142  * Implements : UART_Init_Activity
143  *END**************************************************************************/
145 {
146  status_t status = STATUS_SUCCESS;
147  uint8_t index = 0;
148 
149  /* Define UART PAL over LPUART */
150  #if (defined (UART_OVER_LPUART))
151  if (instance <= LPUART_HIGH_INDEX)
152  {
153  lpuart_user_config_t lpuartConfig;
154 
155  lpuartConfig.baudRate = config->baudRate;
156 
157  /* LPUART supports only 8, 9 or 10 bits per character */
159  (config->bitCount <= UART_10_BITS_PER_CHAR));
160  switch (config->bitCount)
161  {
164  break;
167  break;
170  break;
171  default:
172  /* Impossible type - do nothing */
173  break;
174  }
175 
176  lpuartConfig.parityMode = (lpuart_parity_mode_t)config->parityMode;
177  lpuartConfig.stopBitCount = (lpuart_stop_bit_count_t)config->stopBitCount;
178  lpuartConfig.transferType = (lpuart_transfer_type_t)config->transferType;
179  lpuartConfig.rxDMAChannel = config->rxDMAChannel;
180  lpuartConfig.txDMAChannel = config->txDMAChannel;
181 
182  /* Allocate one of the LPUART state structure for this instance */
183  index = UART_AllocateState(lpuartStateIsAllocated,
184  lpuartStateInstanceMapping,
185  instance,
186  NO_OF_LPUART_INSTS_FOR_UART);
187  /* Initialize LPUART instance */
188  status = LPUART_DRV_Init(instance, (lpuart_state_t*)(&lpuartState[index]), &lpuartConfig);
189 
190  /* Install Rx callback */
191  if (config->rxCallback != NULL)
192  {
193  LPUART_DRV_InstallRxCallback(instance, config->rxCallback, config->rxCallbackParam);
194  }
195 
196  /* Install Tx callback */
197  if (config->txCallback != NULL)
198  {
199  LPUART_DRV_InstallTxCallback(instance, config->txCallback, config->txCallbackParam);
200  }
201  }
202  #endif
203 
204  /* Define UART PAL over FLEXIO */
205  #if (defined (UART_OVER_FLEXIO))
206  if ((instance >= FLEXIO_UART_LOW_INDEX) && (instance <= FLEXIO_UART_HIGH_INDEX))
207  {
208  /* FlexIO driver can be used with parity disabled and one stop bit */
211 
212  flexio_uart_user_config_t flexioUartTxConfig;
213  flexio_uart_user_config_t flexioUartRxConfig;
214 
215  /* Set baud rate for Tx and Rx */
216  flexioUartTxConfig.baudRate = config->baudRate;
217  flexioUartRxConfig.baudRate = config->baudRate;
218 
219  /* Set transfer type for Tx and Rx */
220  switch (config->transferType)
221  {
222  case UART_USING_DMA:
223  flexioUartTxConfig.driverType = FLEXIO_DRIVER_TYPE_DMA;
224  flexioUartRxConfig.driverType = FLEXIO_DRIVER_TYPE_DMA;
225  break;
227  flexioUartTxConfig.driverType = FLEXIO_DRIVER_TYPE_INTERRUPTS;
228  flexioUartRxConfig.driverType = FLEXIO_DRIVER_TYPE_INTERRUPTS;
229  break;
230  default:
231  /* Impossible type - do nothing */
232  break;
233  }
234 
235  /* Set bit count per char for Tx and Rx */
236  switch (config->bitCount)
237  {
239  flexioUartTxConfig.bitCount = 7U;
240  flexioUartRxConfig.bitCount = 7U;
241  break;
243  flexioUartTxConfig.bitCount = 8U;
244  flexioUartRxConfig.bitCount = 8U;
245  break;
247  flexioUartTxConfig.bitCount = 9U;
248  flexioUartRxConfig.bitCount = 9U;
249  break;
251  flexioUartTxConfig.bitCount = 10U;
252  flexioUartRxConfig.bitCount = 10U;
253  break;
255  flexioUartTxConfig.bitCount = 15U;
256  flexioUartRxConfig.bitCount = 15U;
257  break;
259  flexioUartTxConfig.bitCount = 16U;
260  flexioUartRxConfig.bitCount = 16U;
261  break;
262  default:
263  /* Impossible type - do nothing */
264  break;
265  }
266 
267  /* Configure Tx */
268  flexioUartTxConfig.direction = FLEXIO_UART_DIRECTION_TX;
269  flexioUartTxConfig.dmaChannel = config->txDMAChannel;
270  flexioUartTxConfig.dataPin = ((extension_flexio_for_uart_t*)(config->extension))->dataPinTx;
271 
272  /* Configure Rx */
273  flexioUartRxConfig.direction = FLEXIO_UART_DIRECTION_RX;
274  flexioUartRxConfig.dmaChannel = config->rxDMAChannel;
275  flexioUartRxConfig.dataPin = ((extension_flexio_for_uart_t*)(config->extension))->dataPinRx;
276 
277  /* Link Flexio Callbacks to the callbacks defined in PAL */
278  flexioUartRxConfig.callback = config->rxCallback;
279  flexioUartRxConfig.callbackParam = config->rxCallbackParam;
280  flexioUartTxConfig.callback = config->txCallback;
281  flexioUartTxConfig.callbackParam = config->txCallbackParam;
282 
283  status = FLEXIO_DRV_InitDevice(0U, &flexioDeviceState);
284  if (status == STATUS_SUCCESS)
285  {
286  /* Allocate one of the Flexio state structure for this instance */
287  index = UART_AllocateState(flexioUartStateIsAllocated,
288  flexioUartStateInstanceMapping,
289  instance,
290  NO_OF_FLEXIO_INSTS_FOR_UART);
291  /* Init FlexIO UART driver for Tx */
292  status = FLEXIO_UART_DRV_Init(0U,
293  &flexioUartTxConfig,
294  (flexio_uart_state_t*)&flexioUartTxState[index]);
295  /* Init FlexIO UART driver for Rx */
296  status = FLEXIO_UART_DRV_Init(0U,
297  &flexioUartRxConfig,
298  (flexio_uart_state_t*)&flexioUartRxState[index]);
299  }
300 
301  }
302  #endif
303 
304  /* Define UART PAL over LinFlexD */
305  #if (defined (UART_OVER_LINFLEXD))
306  linflexd_uart_user_config_t linFlexDConfig;
307 
308  linFlexDConfig.baudRate = config->baudRate;
309 
310  /* LinFlexD does not support 9 or 10 bits per character */
312  (config->bitCount != UART_10_BITS_PER_CHAR));
313  switch (config->bitCount)
314  {
316  linFlexDConfig.wordLength = LINFLEXD_UART_7_BITS;
317  break;
319  linFlexDConfig.wordLength = LINFLEXD_UART_8_BITS;
320  break;
322  linFlexDConfig.wordLength = LINFLEXD_UART_15_BITS;
323  break;
325  linFlexDConfig.wordLength = LINFLEXD_UART_16_BITS;
326  break;
327  default:
328  /* Impossible type - do nothing */
329  break;
330  }
331 
332  switch (config->parityMode)
333  {
335  linFlexDConfig.parityCheck = false;
336  break;
337  case UART_PARITY_EVEN:
338  linFlexDConfig.parityCheck = true;
339  linFlexDConfig.parityType = LINFLEXD_UART_PARITY_EVEN;
340  break;
341  case UART_PARITY_ODD:
342  linFlexDConfig.parityCheck = true;
343  linFlexDConfig.parityType = LINFLEXD_UART_PARITY_ODD;
344  break;
345  default:
346  /* Impossible type - do nothing */
347  break;
348  }
349 
350  linFlexDConfig.stopBitsCount = (linflexd_uart_stop_bits_count_t)config->stopBitCount;
351  linFlexDConfig.transferType = (linflexd_uart_transfer_type_t)config->transferType;
352  linFlexDConfig.txDMAChannel = config->txDMAChannel;
353  linFlexDConfig.rxDMAChannel = config->rxDMAChannel;
354 
355  /* Allocate one of the LinFlexD state structures for this instance */
356  index = UART_AllocateState(linFlexDStateIsAllocated,
357  linFlexDStateInstanceMapping,
358  instance,
359  NO_OF_LINFLEXD_INSTS_FOR_UART);
360  /* Initialize LinFlexD instance */
361  status = LINFLEXD_UART_DRV_Init(instance, &linFlexDState[index], &linFlexDConfig);
362 
363  /* Install Rx callback */
364  if (config->rxCallback != NULL)
365  {
366  LINFLEXD_UART_DRV_InstallRxCallback(instance, config->rxCallback, config->rxCallbackParam);
367  }
368 
369  /* Install Tx callback */
370  if (config->txCallback != NULL)
371  {
372  LINFLEXD_UART_DRV_InstallTxCallback(instance, config->txCallback, config->txCallbackParam);
373  }
374 
375  #endif
376  return status;
377 }
378 
379 /*FUNCTION**********************************************************************
380  *
381  * Function Name : UART_Deinit
382  * Description : De-initializes the UART module
383  *
384  * Implements : UART_Deinit_Activity
385  *END**************************************************************************/
387 {
388  status_t status = STATUS_SUCCESS;
389 
390  /* Define UART PAL over LPUART */
391  #if defined(UART_OVER_LPUART)
392  if (instance <= LPUART_HIGH_INDEX)
393  {
394  status = LPUART_DRV_Deinit((uint32_t)instance);
395  if (status == STATUS_SUCCESS)
396  {
397  UART_FreeState(lpuartStateIsAllocated,
398  lpuartStateInstanceMapping,
399  instance,
400  NO_OF_LPUART_INSTS_FOR_UART);
401  }
402  }
403  #endif
404 
405  /* Define UART PAL over FLEXIO */
406  #if defined(UART_OVER_FLEXIO)
407  if ((instance >= FLEXIO_UART_LOW_INDEX) && (instance <= FLEXIO_UART_HIGH_INDEX))
408  {
409  uint8_t index = UART_FindFlexioState(instance);
410  status = FLEXIO_UART_DRV_Deinit(&(flexioUartTxState[index]));
411  if (status == STATUS_SUCCESS)
412  {
413  UART_FreeState(flexioUartStateIsAllocated,
414  flexioUartStateInstanceMapping,
415  instance,
416  NO_OF_FLEXIO_INSTS_FOR_UART);
417  }
418  status = FLEXIO_UART_DRV_Deinit(&(flexioUartRxState[index]));
419  if (status == STATUS_SUCCESS)
420  {
421  UART_FreeState(flexioUartStateIsAllocated,
422  flexioUartStateInstanceMapping,
423  instance,
424  NO_OF_FLEXIO_INSTS_FOR_UART);
425  }
426  }
427  #endif
428 
429  /* Define UART PAL over LinFlexD */
430  #if (defined(UART_OVER_LINFLEXD))
431  status = LINFLEXD_UART_DRV_Deinit(instance);
432  if (status == STATUS_SUCCESS)
433  {
434  UART_FreeState(linFlexDStateIsAllocated,
435  linFlexDStateInstanceMapping,
436  instance,
437  NO_OF_LINFLEXD_INSTS_FOR_UART);
438  }
439  #endif
440  return status;
441 }
442 
443 /*FUNCTION**********************************************************************
444  *
445  * Function Name : UART_SetBaudRate
446  * Description : Configures the UART baud rate.
447  *
448  * Implements : UART_SetBaudRate_Activity
449  *END**************************************************************************/
450 status_t UART_SetBaudRate(uart_instance_t instance, uint32_t desiredBaudRate)
451 {
452  status_t status = STATUS_SUCCESS;
453 
454  /* Define UART PAL over LPUART */
455  #if defined(UART_OVER_LPUART)
456  if (instance <= LPUART_HIGH_INDEX)
457  {
458  status = LPUART_DRV_SetBaudRate((uint32_t)instance, desiredBaudRate);
459  }
460  #endif
461 
462  /* Define UART PAL over FLEXIO */
463  #if defined(UART_OVER_FLEXIO)
464  if ((instance >= FLEXIO_UART_LOW_INDEX) && (instance <= FLEXIO_UART_HIGH_INDEX))
465  {
466  uint8_t index = UART_FindFlexioState(instance);
467  uint8_t bitCount = (flexioUartTxState[index]).bitCount;
468  status = FLEXIO_UART_DRV_SetConfig(&(flexioUartTxState[index]),
469  desiredBaudRate,
470  bitCount);
471  status = FLEXIO_UART_DRV_SetConfig(&(flexioUartRxState[index]),
472  desiredBaudRate,
473  bitCount);
474  }
475  #endif
476 
477  /* Define UART PAL over LinFlexD */
478  #if (defined(UART_OVER_LINFLEXD))
479  status = LINFLEXD_UART_DRV_SetBaudRate(instance, desiredBaudRate);
480  #endif
481  return status;
482 }
483 
492 status_t UART_GetBaudRate(uart_instance_t instance, uint32_t * configuredBaudRate)
493 {
494  status_t status = STATUS_SUCCESS;
495 
496  /* Define UART PAL over LPUART */
497  #if defined(UART_OVER_LPUART)
498  if (instance <= LPUART_HIGH_INDEX)
499  {
500  LPUART_DRV_GetBaudRate((uint32_t)instance, configuredBaudRate);
501  }
502  #endif
503 
504  /* Define UART PAL over FLEXIO */
505  #if defined(UART_OVER_FLEXIO)
506  if ((instance >= FLEXIO_UART_LOW_INDEX) && (instance <= FLEXIO_UART_HIGH_INDEX))
507  {
508  status = FLEXIO_UART_DRV_GetBaudRate(&(flexioUartTxState[UART_FindFlexioState(instance)]),
509  configuredBaudRate);
510  }
511  #endif
512 
513  /* Define UART PAL over LinFlexD */
514  #if (defined(UART_OVER_LINFLEXD))
515  status = LINFLEXD_UART_DRV_GetBaudRate(instance, configuredBaudRate);
516  #endif
517 
518  return status;
519 }
520 
521 /*FUNCTION**********************************************************************
522  *
523  * Function Name : UART_SendDataBlocking
524  * Description : Perform a blocking UART transmission
525  *
526  * Implements : UART_SendDataBlocking_Activity
527  *END**************************************************************************/
529  uart_instance_t instance,
530  const uint8_t * txBuff,
531  uint32_t txSize,
532  uint32_t timeout)
533 {
534  status_t status = STATUS_SUCCESS;
535 
536  /* Define UART PAL over LPUART */
537  #if defined(UART_OVER_LPUART)
538  if (instance <= LPUART_HIGH_INDEX)
539  {
540  status = LPUART_DRV_SendDataBlocking((uint32_t)instance, txBuff, txSize, timeout);
541  }
542  #endif
543 
544  /* Define UART PAL over FLEXIO */
545  #if defined(UART_OVER_FLEXIO)
546  if ((instance >= FLEXIO_UART_LOW_INDEX) && (instance <= FLEXIO_UART_HIGH_INDEX))
547  {
549  &(flexioUartTxState[UART_FindFlexioState(instance)]),
550  txBuff,
551  txSize,
552  timeout);
553  }
554  #endif
555 
556  /* Define UART PAL over LinFlexD */
557  #if (defined(UART_OVER_LINFLEXD))
558  status = LINFLEXD_UART_DRV_SendDataBlocking(instance, txBuff, txSize, timeout);
559  #endif
560  return status;
561 }
562 
563 /*FUNCTION**********************************************************************
564  *
565  * Function Name : UART_SendData
566  * Description : Perform a non-blocking UART transmission
567  *
568  * Implements : UART_SendData_Activity
569  *END**************************************************************************/
570 status_t UART_SendData(uart_instance_t instance, const uint8_t * txBuff, uint32_t txSize)
571 {
572  status_t status = STATUS_SUCCESS;
573 
574  /* Define UART PAL over LPUART */
575  #if defined(UART_OVER_LPUART)
576 
577  if (instance <= LPUART_HIGH_INDEX)
578  {
579  status = LPUART_DRV_SendData((uint32_t)instance, txBuff, txSize);
580  }
581  #endif
582 
583  /* Define UART PAL over FLEXIO */
584  #if defined(UART_OVER_FLEXIO)
585  if ((instance >= FLEXIO_UART_LOW_INDEX) && (instance <= FLEXIO_UART_HIGH_INDEX))
586  {
587  status = FLEXIO_UART_DRV_SendData(
588  &(flexioUartTxState[UART_FindFlexioState(instance)]),
589  txBuff,
590  txSize);
591  }
592  #endif
593 
594  /* Define UART PAL over LinFlexD */
595  #if (defined(UART_OVER_LINFLEXD))
596  status = LINFLEXD_UART_DRV_SendData(instance, txBuff, txSize);
597  #endif
598  return status;
599 }
600 
601 /*FUNCTION**********************************************************************
602  *
603  * Function Name : UART_AbortSendingData
604  * Description : This function terminates an non-blocking transmission early.
605  *
606  * Implements : UART_AbortSendingData_Activity
607  *END**************************************************************************/
609 {
610  status_t status = STATUS_SUCCESS;
611 
612  /* Define UART PAL over LPUART */
613  #if defined(UART_OVER_LPUART)
614  if (instance <= LPUART_HIGH_INDEX)
615  {
616  status = LPUART_DRV_AbortSendingData(instance);
617  }
618  #endif
619 
620  /* Define UART PAL over FLEXIO */
621  #if defined(UART_OVER_FLEXIO)
622  if ((instance >= FLEXIO_UART_LOW_INDEX) && (instance <= FLEXIO_UART_HIGH_INDEX))
623  {
624  status = FLEXIO_UART_DRV_TransferAbort(&(flexioUartTxState[UART_FindFlexioState(instance)]));
625  }
626  #endif
627 
628  /* Define UART PAL over LinFlexD */
629  #if (defined(UART_OVER_LINFLEXD))
630  status = LINFLEXD_UART_DRV_AbortSendingData(instance);
631  #endif
632  return status;
633 }
634 
635 /*FUNCTION**********************************************************************
636  *
637  * Function Name : UART_GetTransmitStatus
638  * Description : This function returns whether the previous transmission has
639  * finished
640  *
641  * Implements : UART_GetTransmitStatus_Activity
642  *END**************************************************************************/
643 status_t UART_GetTransmitStatus(uart_instance_t instance, uint32_t * bytesRemaining)
644 {
645  status_t status = STATUS_SUCCESS;
646 
647  /* Define UART PAL over LPUART */
648  #if defined(UART_OVER_LPUART)
649  if (instance <= LPUART_HIGH_INDEX)
650  {
651  status = LPUART_DRV_GetTransmitStatus(instance, bytesRemaining);
652  }
653  #endif
654 
655  /* Define UART PAL over FLEXIO */
656  #if defined(UART_OVER_FLEXIO)
657  if ((instance >= FLEXIO_UART_LOW_INDEX) && (instance <= FLEXIO_UART_HIGH_INDEX))
658  {
659  status = FLEXIO_UART_DRV_GetStatus(
660  &(flexioUartTxState[UART_FindFlexioState(instance)]),
661  bytesRemaining);
662  }
663  #endif
664 
665  /* Define UART PAL over LinFlexD */
666  #if (defined(UART_OVER_LINFLEXD))
667  status = LINFLEXD_UART_DRV_GetTransmitStatus(instance, bytesRemaining);
668  #endif
669  return status;
670 }
671 
672 /*FUNCTION**********************************************************************
673  *
674  * Function Name : UART_ReceiveDataBlocking
675  * Description : Perform a blocking UART reception
676  *
677  * Implements : UART_ReceiveDataBlocking_Activity
678  *END**************************************************************************/
680  uart_instance_t instance,
681  uint8_t * rxBuff,
682  uint32_t rxSize,
683  uint32_t timeout)
684 {
685  status_t status = STATUS_SUCCESS;
686 
687  /* Define UART PAL over LPUART */
688  #if defined(UART_OVER_LPUART)
689  if (instance <= LPUART_HIGH_INDEX)
690  {
691  status = LPUART_DRV_ReceiveDataBlocking((uint32_t)instance, rxBuff, rxSize, timeout);
692  }
693  #endif
694 
695  /* Define UART PAL over FLEXIO */
696  #if defined(UART_OVER_FLEXIO)
697  if ((instance >= FLEXIO_UART_LOW_INDEX) && (instance <= FLEXIO_UART_HIGH_INDEX))
698  {
700  &(flexioUartRxState[UART_FindFlexioState(instance)]),
701  rxBuff,
702  rxSize,
703  timeout);
704  }
705  #endif
706 
707  /* Define UART PAL over LinFlexD */
708  #if (defined(UART_OVER_LINFLEXD))
709  status = LINFLEXD_UART_DRV_ReceiveDataBlocking(instance, rxBuff, rxSize, timeout);
710  #endif
711  return status;
712 }
713 
714 /*FUNCTION**********************************************************************
715  *
716  * Function Name : UART_ReceiveData
717  * Description : Perform a non-blocking UART reception
718  *
719  * Implements : UART_ReceiveData_Activity
720  *END**************************************************************************/
721 status_t UART_ReceiveData(uart_instance_t instance, uint8_t * rxBuff, uint32_t rxSize)
722 {
723  status_t status = STATUS_SUCCESS;
724 
725  /* Define UART PAL over LPUART */
726  #if defined(UART_OVER_LPUART)
727  if (instance <= LPUART_HIGH_INDEX)
728  {
729  status = LPUART_DRV_ReceiveData((uint32_t)instance, rxBuff, rxSize);
730  }
731  #endif
732 
733  /* Define UART PAL over FLEXIO */
734  #if defined(UART_OVER_FLEXIO)
735  if ((instance >= FLEXIO_UART_LOW_INDEX) && (instance <= FLEXIO_UART_HIGH_INDEX))
736  {
738  &(flexioUartRxState[UART_FindFlexioState(instance)]),
739  rxBuff,
740  rxSize);
741  }
742  #endif
743 
744  /* Define UART PAL over LinFlexD */
745  #if (defined(UART_OVER_LINFLEXD))
746  status = LINFLEXD_UART_DRV_ReceiveData(instance, rxBuff, rxSize);
747  #endif
748  return status;
749 }
750 
751 /*FUNCTION**********************************************************************
752  *
753  * Function Name : UART_AbortReceivingData
754  * Description : Terminates a non-blocking receive early.
755  *
756  * Implements : UART_AbortReceivingData_Activity
757  *END**************************************************************************/
759 {
760  status_t status = STATUS_SUCCESS;
761 
762  /* Define UART PAL over LPUART */
763  #if defined(UART_OVER_LPUART)
764  if (instance <= LPUART_HIGH_INDEX)
765  {
766  status = LPUART_DRV_AbortReceivingData(instance);
767  }
768  #endif
769 
770  /* Define UART PAL over FLEXIO */
771  #if defined(UART_OVER_FLEXIO)
772  if ((instance >= FLEXIO_UART_LOW_INDEX) && (instance <= FLEXIO_UART_HIGH_INDEX))
773  {
774  status = FLEXIO_UART_DRV_TransferAbort(&(flexioUartRxState[UART_FindFlexioState(instance)]));
775  }
776  #endif
777 
778  /* Define UART PAL over LinFlexD */
779  #if (defined(UART_OVER_LINFLEXD))
780  status = LINFLEXD_UART_DRV_AbortReceivingData(instance);
781  #endif
782  return status;
783 }
784 
785 /*FUNCTION**********************************************************************
786  *
787  * Function Name : UART_GetReceiveStatus
788  * Description : This function returns whether the previous reception has
789  * finished
790  *
791  * Implements : UART_GetReceiveStatus_Activity
792  *END**************************************************************************/
793 status_t UART_GetReceiveStatus(uart_instance_t instance, uint32_t * bytesRemaining)
794 {
795  status_t status = STATUS_SUCCESS;
796 
797  /* Define UART PAL over LPUART */
798  #if defined(UART_OVER_LPUART)
799  if (instance <= LPUART_HIGH_INDEX)
800  {
801  status = LPUART_DRV_GetReceiveStatus(instance, bytesRemaining);
802  }
803  #endif
804 
805  /* Define UART PAL over FLEXIO */
806  #if defined(UART_OVER_FLEXIO)
807  if ((instance >= FLEXIO_UART_LOW_INDEX) && (instance <= FLEXIO_UART_HIGH_INDEX))
808  {
809  status = FLEXIO_UART_DRV_GetStatus(&(flexioUartRxState[UART_FindFlexioState(instance)]),
810  bytesRemaining);
811  }
812  #endif
813 
814  /* Define UART PAL over LinFlexD */
815  #if (defined(UART_OVER_LINFLEXD))
816  status = LINFLEXD_UART_DRV_GetReceiveStatus(instance, bytesRemaining);
817  #endif
818  return status;
819 }
820 
821 /*******************************************************************************
822  * EOF
823  ******************************************************************************/
status_t UART_GetReceiveStatus(uart_instance_t instance, uint32_t *bytesRemaining)
Get the status of the current non-blocking UART reception.
Definition: uart_pal.c:793
status_t UART_SetBaudRate(uart_instance_t instance, uint32_t desiredBaudRate)
Configures the UART baud rate.
Definition: uart_pal.c:450
status_t LPUART_DRV_AbortSendingData(uint32_t instance)
Terminates a non-blocking transmission early.
status_t UART_ReceiveDataBlocking(uart_instance_t instance, uint8_t *rxBuff, uint32_t rxSize, uint32_t timeout)
Perform a blocking UART reception.
Definition: uart_pal.c:679
status_t LPUART_DRV_SendDataBlocking(uint32_t instance, const uint8_t *txBuff, uint32_t txSize, uint32_t timeout)
Sends data out through the LPUART module using a blocking method.
uart_callback_t LPUART_DRV_InstallTxCallback(uint32_t instance, uart_callback_t function, void *callbackParam)
Installs callback function for the LPUART transmit.
status_t LPUART_DRV_Deinit(uint32_t instance)
Shuts down the LPUART by disabling interrupts and transmitter/receiver.
status_t UART_Init(uart_instance_t instance, uart_user_config_t *config)
Initializes the UART module.
Definition: uart_pal.c:144
uint8_t txDMAChannel
Definition: uart_pal.h:86
status_t LPUART_DRV_SendData(uint32_t instance, const uint8_t *txBuff, uint32_t txSize)
Sends data out through the LPUART module using a non-blocking method. This enables an a-sync method f...
status_t FLEXIO_UART_DRV_ReceiveData(flexio_uart_state_t *state, uint8_t *rxBuff, uint32_t rxSize)
Perform a non-blocking UART reception.
status_t LPUART_DRV_AbortReceivingData(uint32_t instance)
Terminates a non-blocking receive early.
status_t UART_SendData(uart_instance_t instance, const uint8_t *txBuff, uint32_t txSize)
Perform a non-blocking UART transmission.
Definition: uart_pal.c:570
uint32_t baudRate
Definition: uart_pal.h:80
status_t UART_Deinit(uart_instance_t instance)
De-initializes the UART module.
Definition: uart_pal.c:386
uart_bit_count_per_char_t bitCount
Definition: uart_pal.h:81
status_t UART_GetBaudRate(uart_instance_t instance, uint32_t *configuredBaudRate)
Returns the UART baud rate.
Definition: uart_pal.c:492
status_t FLEXIO_UART_DRV_SetConfig(flexio_uart_state_t *state, uint32_t baudRate, uint8_t bitCount)
Set the baud rate and bit width for any subsequent UART communication.
status_t UART_AbortSendingData(uart_instance_t instance)
Terminates a non-blocking transmission early.
Definition: uart_pal.c:608
lpuart_bit_count_per_char_t bitCountPerChar
status_t UART_AbortReceivingData(uart_instance_t instance)
Terminates a non-blocking receive early.
Definition: uart_pal.c:758
void * extension
Definition: uart_pal.h:91
status_t FLEXIO_UART_DRV_SendData(flexio_uart_state_t *state, const uint8_t *txBuff, uint32_t txSize)
Perform a non-blocking UART transmission.
lpuart_parity_mode_t parityMode
#define DEV_ASSERT(x)
Definition: devassert.h:77
status_t UART_ReceiveData(uart_instance_t instance, uint8_t *rxBuff, uint32_t rxSize)
Perform a non-blocking UART reception.
Definition: uart_pal.c:721
status_t FLEXIO_UART_DRV_SendDataBlocking(flexio_uart_state_t *state, const uint8_t *txBuff, uint32_t txSize, uint32_t timeout)
Perform a blocking UART transmission.
uart_parity_mode_t parityMode
Definition: uart_pal.h:82
flexio_uart_driver_direction_t direction
status_t FLEXIO_UART_DRV_ReceiveDataBlocking(flexio_uart_state_t *state, uint8_t *rxBuff, uint32_t rxSize, uint32_t timeout)
Perform a blocking UART reception.
status_t LPUART_DRV_ReceiveData(uint32_t instance, uint8_t *rxBuff, uint32_t rxSize)
Gets data from the LPUART module by using a non-blocking method. This enables an a-sync method for re...
lpuart_transfer_type_t
Type of LPUART transfer (based on interrupts or DMA).
Definition: lpuart_driver.h:46
uart_instance_t
status_t FLEXIO_UART_DRV_GetBaudRate(flexio_uart_state_t *state, uint32_t *baudRate)
Get the currently configured baud rate.
void * rxCallbackParam
Definition: uart_pal.h:88
status_t UART_GetTransmitStatus(uart_instance_t instance, uint32_t *bytesRemaining)
Get the status of the current non-blocking UART transmission.
Definition: uart_pal.c:643
lpuart_parity_mode_t
LPUART parity mode.
Definition: lpuart_driver.h:67
uart_callback_t LPUART_DRV_InstallRxCallback(uint32_t instance, uart_callback_t function, void *callbackParam)
Installs callback function for the LPUART receive.
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 FLEXIO_UART_DRV_GetStatus(flexio_uart_state_t *state, uint32_t *bytesRemaining)
Get the status of the current non-blocking UART transfer.
uart_callback_t txCallback
Definition: uart_pal.h:89
status_t LPUART_DRV_SetBaudRate(uint32_t instance, uint32_t desiredBaudRate)
Configures the LPUART baud rate.
Driver internal context structure.
status_t FLEXIO_UART_DRV_Deinit(flexio_uart_state_t *state)
De-initialize the FLEXIO_UART driver.
uint8_t rxDMAChannel
Definition: uart_pal.h:85
status_t FLEXIO_UART_DRV_TransferAbort(flexio_uart_state_t *state)
Aborts a non-blocking UART transfer.
status_t LPUART_DRV_Init(uint32_t instance, lpuart_state_t *lpuartStatePtr, const lpuart_user_config_t *lpuartUserConfig)
Initializes an LPUART operation instance.
static void UART_FreeState(bool *isAllocated, uart_instance_t *instanceMapping, uart_instance_t instance, uint8_t numberOfinstances)
Definition: uart_pal.c:99
void * txCallbackParam
Definition: uart_pal.h:90
status_t LPUART_DRV_ReceiveDataBlocking(uint32_t instance, uint8_t *rxBuff, uint32_t rxSize, uint32_t timeout)
Gets data from the LPUART module by using a blocking method. Blocking means that the function does no...
#define FLEXIO_UART_LOW_INDEX
static uint8_t UART_AllocateState(bool *isAllocated, uart_instance_t *instanceMapping, uart_instance_t instance, uint8_t numberOfinstances)
Definition: uart_pal.c:74
LPUART configuration structure.
lpuart_stop_bit_count_t
LPUART number of stop bits.
Definition: lpuart_driver.h:78
flexio_driver_type_t driverType
void LPUART_DRV_GetBaudRate(uint32_t instance, uint32_t *configuredBaudRate)
Returns the LPUART baud rate.
status_t LPUART_DRV_GetTransmitStatus(uint32_t instance, uint32_t *bytesRemaining)
Returns whether the previous transmit is complete.
Driver configuration structure.
lpuart_transfer_type_t transferType
status_t FLEXIO_UART_DRV_Init(uint32_t instance, const flexio_uart_user_config_t *userConfigPtr, flexio_uart_state_t *state)
Initialize the FLEXIO_UART driver.
Runtime state of the LPUART driver.
Definition: lpuart_driver.h:92
status_t FLEXIO_DRV_InitDevice(uint32_t instance, flexio_device_state_t *deviceState)
Initializes the FlexIO device.
Definition: flexio_common.c:89
uart_callback_t rxCallback
Definition: uart_pal.h:87
status_t LPUART_DRV_GetReceiveStatus(uint32_t instance, uint32_t *bytesRemaining)
Returns whether the previous receive is complete.
uart_transfer_type_t transferType
Definition: uart_pal.h:84
status_t UART_SendDataBlocking(uart_instance_t instance, const uint8_t *txBuff, uint32_t txSize, uint32_t timeout)
Perform a blocking UART transmission.
Definition: uart_pal.c:528
#define LPUART_HIGH_INDEX
#define FLEXIO_UART_HIGH_INDEX
lpuart_stop_bit_count_t stopBitCount
uart_stop_bit_count_t stopBitCount
Definition: uart_pal.h:83