rusEFI
The most advanced open source ECU
Loading...
Searching...
No Matches
Typedefs | Enumerations | Functions | Variables
fsl_lpuart.c File Reference

Typedefs

typedef void(* lpuart_isr_t) (LPUART_Type *base, lpuart_handle_t *handle)
 

Enumerations

enum  _lpuart_transfer_states { kLPUART_TxIdle , kLPUART_TxBusy , kLPUART_RxIdle , kLPUART_RxBusy }
 

Functions

static bool LPUART_TransferIsRxRingBufferFull (LPUART_Type *base, lpuart_handle_t *handle)
 Check whether the RX ring buffer is full.
 
void LPUART_WriteNonBlocking (LPUART_Type *base, const uint8_t *data, size_t length)
 Write to TX register using non-blocking method.
 
static void LPUART_ReadNonBlocking (LPUART_Type *base, uint8_t *data, size_t length)
 Read RX register using non-blocking method.
 
uint32_t LPUART_GetInstance (LPUART_Type *base)
 Get the LPUART instance from peripheral base address.
 
size_t LPUART_TransferGetRxRingBufferLength (LPUART_Type *base, lpuart_handle_t *handle)
 Get the length of received data in RX ring buffer.
 
status_t LPUART_Init (LPUART_Type *base, const lpuart_config_t *config, uint32_t srcClock_Hz)
 Initializes an LPUART instance with the user configuration structure and the peripheral clock.
 
void LPUART_Deinit (LPUART_Type *base)
 Deinitializes a LPUART instance.
 
void LPUART_GetDefaultConfig (lpuart_config_t *config)
 Gets the default configuration structure.
 
status_t LPUART_SetBaudRate (LPUART_Type *base, uint32_t baudRate_Bps, uint32_t srcClock_Hz)
 Sets the LPUART instance baudrate.
 
void LPUART_EnableInterrupts (LPUART_Type *base, uint32_t mask)
 Enables LPUART interrupts according to a provided mask.
 
void LPUART_DisableInterrupts (LPUART_Type *base, uint32_t mask)
 Disables LPUART interrupts according to a provided mask.
 
uint32_t LPUART_GetEnabledInterrupts (LPUART_Type *base)
 Gets enabled LPUART interrupts.
 
uint32_t LPUART_GetStatusFlags (LPUART_Type *base)
 Gets LPUART status flags.
 
status_t LPUART_ClearStatusFlags (LPUART_Type *base, uint32_t mask)
 Clears status flags with a provided mask.
 
void LPUART_WriteBlocking (LPUART_Type *base, const uint8_t *data, size_t length)
 Writes to the transmitter register using a blocking method.
 
status_t LPUART_ReadBlocking (LPUART_Type *base, uint8_t *data, size_t length)
 Reads the receiver data register using a blocking method.
 
void LPUART_TransferCreateHandle (LPUART_Type *base, lpuart_handle_t *handle, lpuart_transfer_callback_t callback, void *userData)
 Initializes the LPUART handle.
 
void LPUART_TransferStartRingBuffer (LPUART_Type *base, lpuart_handle_t *handle, uint8_t *ringBuffer, size_t ringBufferSize)
 Sets up the RX ring buffer.
 
void LPUART_TransferStopRingBuffer (LPUART_Type *base, lpuart_handle_t *handle)
 Aborts the background transfer and uninstalls the ring buffer.
 
status_t LPUART_TransferSendNonBlocking (LPUART_Type *base, lpuart_handle_t *handle, lpuart_transfer_t *xfer)
 Transmits a buffer of data using the interrupt method.
 
void LPUART_TransferAbortSend (LPUART_Type *base, lpuart_handle_t *handle)
 Aborts the interrupt-driven data transmit.
 
status_t LPUART_TransferGetSendCount (LPUART_Type *base, lpuart_handle_t *handle, uint32_t *count)
 Gets the number of bytes that have been written to the LPUART transmitter register.
 
status_t LPUART_TransferReceiveNonBlocking (LPUART_Type *base, lpuart_handle_t *handle, lpuart_transfer_t *xfer, size_t *receivedBytes)
 Receives a buffer of data using the interrupt method.
 
void LPUART_TransferAbortReceive (LPUART_Type *base, lpuart_handle_t *handle)
 Aborts the interrupt-driven data receiving.
 
status_t LPUART_TransferGetReceiveCount (LPUART_Type *base, lpuart_handle_t *handle, uint32_t *count)
 Gets the number of bytes that have been received.
 
void LPUART_TransferHandleIRQ (LPUART_Type *base, lpuart_handle_t *handle)
 LPUART IRQ handle function.
 
void LPUART_TransferHandleErrorIRQ (LPUART_Type *base, lpuart_handle_t *handle)
 LPUART Error IRQ handle function.
 
void LPUART0_LPUART1_RX_DriverIRQHandler (void)
 
void LPUART0_LPUART1_TX_DriverIRQHandler (void)
 
void LPUART0_LPUART1_DriverIRQHandler (void)
 
void LPUART0_TX_DriverIRQHandler (void)
 
void LPUART0_RX_DriverIRQHandler (void)
 
void LPUART0_DriverIRQHandler (void)
 
void LPUART1_TX_DriverIRQHandler (void)
 
void LPUART1_RX_DriverIRQHandler (void)
 
void LPUART1_DriverIRQHandler (void)
 
void LPUART2_TX_DriverIRQHandler (void)
 
void LPUART2_RX_DriverIRQHandler (void)
 
void LPUART2_DriverIRQHandler (void)
 
void LPUART3_TX_DriverIRQHandler (void)
 
void LPUART3_RX_DriverIRQHandler (void)
 
void LPUART3_DriverIRQHandler (void)
 
void LPUART4_TX_DriverIRQHandler (void)
 
void LPUART4_RX_DriverIRQHandler (void)
 
void LPUART4_DriverIRQHandler (void)
 
void LPUART5_TX_DriverIRQHandler (void)
 
void LPUART5_RX_DriverIRQHandler (void)
 
void LPUART5_DriverIRQHandler (void)
 
void LPUART6_TX_DriverIRQHandler (void)
 
void LPUART6_RX_DriverIRQHandler (void)
 
void LPUART6_DriverIRQHandler (void)
 
void LPUART7_TX_DriverIRQHandler (void)
 
void LPUART7_RX_DriverIRQHandler (void)
 
void LPUART7_DriverIRQHandler (void)
 
void LPUART8_TX_DriverIRQHandler (void)
 
void LPUART8_RX_DriverIRQHandler (void)
 
void LPUART8_DriverIRQHandler (void)
 
void M4_0_LPUART_DriverIRQHandler (void)
 
void M4_1_LPUART_DriverIRQHandler (void)
 
void M4_LPUART_DriverIRQHandler (void)
 
void DMA_UART0_INT_DriverIRQHandler (void)
 
void DMA_UART1_INT_DriverIRQHandler (void)
 
void DMA_UART2_INT_DriverIRQHandler (void)
 
void DMA_UART3_INT_DriverIRQHandler (void)
 
void DMA_UART4_INT_DriverIRQHandler (void)
 
void ADMA_UART0_INT_DriverIRQHandler (void)
 
void ADMA_UART1_INT_DriverIRQHandler (void)
 
void ADMA_UART2_INT_DriverIRQHandler (void)
 
void ADMA_UART3_INT_DriverIRQHandler (void)
 

Variables

static LPUART_Type *const s_lpuartBases [] = LPUART_BASE_PTRS
 
static lpuart_handle_t * s_lpuartHandle [ARRAY_SIZE(s_lpuartBases)]
 
static const IRQn_Type s_lpuartRxIRQ [] = LPUART_RX_IRQS
 
static const IRQn_Type s_lpuartTxIRQ [] = LPUART_TX_IRQS
 
static const IRQn_Type s_lpuartIRQ [] = LPUART_RX_TX_IRQS
 
static const clock_ip_name_t s_lpuartClock [] = LPUART_CLOCKS
 
static const clock_ip_name_t s_lpuartPeriphClocks [] = LPUART_PERIPH_CLOCKS
 
static lpuart_isr_t s_lpuartIsr
 

Typedef Documentation

◆ lpuart_isr_t

typedef void(* lpuart_isr_t) (LPUART_Type *base, lpuart_handle_t *handle)

Definition at line 31 of file fsl_lpuart.c.

Enumeration Type Documentation

◆ _lpuart_transfer_states

enum _lpuart_transfer_states
Enumerator
kLPUART_TxIdle 

TX idle.

kLPUART_TxBusy 

TX busy.

kLPUART_RxIdle 

RX idle.

kLPUART_RxBusy 

RX busy.

Definition at line 22 of file fsl_lpuart.c.

23{
24 kLPUART_TxIdle, /*!< TX idle. */
25 kLPUART_TxBusy, /*!< TX busy. */
26 kLPUART_RxIdle, /*!< RX idle. */
27 kLPUART_RxBusy /*!< RX busy. */
28};
kLPUART_TxIdle
@ kLPUART_TxIdle
Definition fsl_lpuart.c:24
kLPUART_RxBusy
@ kLPUART_RxBusy
Definition fsl_lpuart.c:27
kLPUART_TxBusy
@ kLPUART_TxBusy
Definition fsl_lpuart.c:25
kLPUART_RxIdle
@ kLPUART_RxIdle
Definition fsl_lpuart.c:26

Function Documentation

◆ ADMA_UART0_INT_DriverIRQHandler()

void ADMA_UART0_INT_DriverIRQHandler ( void  )

Definition at line 2055 of file fsl_lpuart.c.

2056{
2057 s_lpuartIsr(ADMA__LPUART0, s_lpuartHandle[LPUART_GetInstance(ADMA__LPUART0)]);
2058/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2059 exception return operation might vector to incorrect interrupt */
2060#if defined __CORTEX_M && (__CORTEX_M == 4U)
2061 __DSB();
2062#endif
2063}
s_lpuartHandle
static lpuart_handle_t * s_lpuartHandle[ARRAY_SIZE(s_lpuartBases)]
Definition fsl_lpuart.c:80
s_lpuartIsr
static lpuart_isr_t s_lpuartIsr
Definition fsl_lpuart.c:100
LPUART_GetInstance
uint32_t LPUART_GetInstance(LPUART_Type *base)
Get the LPUART instance from peripheral base address.
Definition fsl_lpuart.c:111
Here is the call graph for this function:

◆ ADMA_UART1_INT_DriverIRQHandler()

void ADMA_UART1_INT_DriverIRQHandler ( void  )

Definition at line 2067 of file fsl_lpuart.c.

2068{
2069 s_lpuartIsr(ADMA__LPUART1, s_lpuartHandle[LPUART_GetInstance(ADMA__LPUART1)]);
2070/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2071 exception return operation might vector to incorrect interrupt */
2072#if defined __CORTEX_M && (__CORTEX_M == 4U)
2073 __DSB();
2074#endif
2075}
Here is the call graph for this function:

◆ ADMA_UART2_INT_DriverIRQHandler()

void ADMA_UART2_INT_DriverIRQHandler ( void  )

Definition at line 2079 of file fsl_lpuart.c.

2080{
2081 s_lpuartIsr(ADMA__LPUART2, s_lpuartHandle[LPUART_GetInstance(ADMA__LPUART2)]);
2082/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2083 exception return operation might vector to incorrect interrupt */
2084#if defined __CORTEX_M && (__CORTEX_M == 4U)
2085 __DSB();
2086#endif
2087}
Here is the call graph for this function:

◆ ADMA_UART3_INT_DriverIRQHandler()

void ADMA_UART3_INT_DriverIRQHandler ( void  )

Definition at line 2091 of file fsl_lpuart.c.

2092{
2093 s_lpuartIsr(ADMA__LPUART3, s_lpuartHandle[LPUART_GetInstance(ADMA__LPUART3)]);
2094/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2095 exception return operation might vector to incorrect interrupt */
2096#if defined __CORTEX_M && (__CORTEX_M == 4U)
2097 __DSB();
2098#endif
2099}
Here is the call graph for this function:

◆ DMA_UART0_INT_DriverIRQHandler()

void DMA_UART0_INT_DriverIRQHandler ( void  )

Definition at line 1995 of file fsl_lpuart.c.

1996{
1997 s_lpuartIsr(DMA__LPUART0, s_lpuartHandle[LPUART_GetInstance(DMA__LPUART0)]);
1998/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1999 exception return operation might vector to incorrect interrupt */
2000#if defined __CORTEX_M && (__CORTEX_M == 4U)
2001 __DSB();
2002#endif
2003}
Here is the call graph for this function:

◆ DMA_UART1_INT_DriverIRQHandler()

void DMA_UART1_INT_DriverIRQHandler ( void  )

Definition at line 2007 of file fsl_lpuart.c.

2008{
2009 s_lpuartIsr(DMA__LPUART1, s_lpuartHandle[LPUART_GetInstance(DMA__LPUART1)]);
2010/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2011 exception return operation might vector to incorrect interrupt */
2012#if defined __CORTEX_M && (__CORTEX_M == 4U)
2013 __DSB();
2014#endif
2015}
Here is the call graph for this function:

◆ DMA_UART2_INT_DriverIRQHandler()

void DMA_UART2_INT_DriverIRQHandler ( void  )

Definition at line 2019 of file fsl_lpuart.c.

2020{
2021 s_lpuartIsr(DMA__LPUART2, s_lpuartHandle[LPUART_GetInstance(DMA__LPUART2)]);
2022/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2023 exception return operation might vector to incorrect interrupt */
2024#if defined __CORTEX_M && (__CORTEX_M == 4U)
2025 __DSB();
2026#endif
2027}
Here is the call graph for this function:

◆ DMA_UART3_INT_DriverIRQHandler()

void DMA_UART3_INT_DriverIRQHandler ( void  )

Definition at line 2031 of file fsl_lpuart.c.

2032{
2033 s_lpuartIsr(DMA__LPUART3, s_lpuartHandle[LPUART_GetInstance(DMA__LPUART3)]);
2034/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2035 exception return operation might vector to incorrect interrupt */
2036#if defined __CORTEX_M && (__CORTEX_M == 4U)
2037 __DSB();
2038#endif
2039}
Here is the call graph for this function:

◆ DMA_UART4_INT_DriverIRQHandler()

void DMA_UART4_INT_DriverIRQHandler ( void  )

Definition at line 2043 of file fsl_lpuart.c.

2044{
2045 s_lpuartIsr(DMA__LPUART4, s_lpuartHandle[LPUART_GetInstance(DMA__LPUART4)]);
2046/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2047 exception return operation might vector to incorrect interrupt */
2048#if defined __CORTEX_M && (__CORTEX_M == 4U)
2049 __DSB();
2050#endif
2051}
Here is the call graph for this function:

◆ LPUART0_DriverIRQHandler()

void LPUART0_DriverIRQHandler ( void  )

Definition at line 1679 of file fsl_lpuart.c.

1680{
1681 s_lpuartIsr(LPUART0, s_lpuartHandle[0]);
1682/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1683 exception return operation might vector to incorrect interrupt */
1684#if defined __CORTEX_M && (__CORTEX_M == 4U)
1685 __DSB();
1686#endif
1687}

◆ LPUART0_LPUART1_DriverIRQHandler()

void LPUART0_LPUART1_DriverIRQHandler ( void  )

Definition at line 1628 of file fsl_lpuart.c.

1629{
1630 if (CLOCK_isEnabledClock(s_lpuartClock[0]))
1631 {
1632 if ((LPUART_STAT_OR_MASK & LPUART0->STAT) ||
1633 ((LPUART_STAT_RDRF_MASK & LPUART0->STAT) && (LPUART_CTRL_RIE_MASK & LPUART0->CTRL)) ||
1634 ((LPUART0->STAT & LPUART_STAT_TDRE_MASK) && (LPUART0->CTRL & LPUART_CTRL_TIE_MASK)))
1635 {
1636 s_lpuartIsr(LPUART0, s_lpuartHandle[0]);
1637 }
1638 }
1639 if (CLOCK_isEnabledClock(s_lpuartClock[1]))
1640 {
1641 if ((LPUART_STAT_OR_MASK & LPUART1->STAT) ||
1642 ((LPUART_STAT_RDRF_MASK & LPUART1->STAT) && (LPUART_CTRL_RIE_MASK & LPUART1->CTRL)) ||
1643 ((LPUART1->STAT & LPUART_STAT_TDRE_MASK) && (LPUART1->CTRL & LPUART_CTRL_TIE_MASK)))
1644 {
1645 s_lpuartIsr(LPUART1, s_lpuartHandle[1]);
1646 }
1647 }
1648/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1649 exception return operation might vector to incorrect interrupt */
1650#if defined __CORTEX_M && (__CORTEX_M == 4U)
1651 __DSB();
1652#endif
1653}
s_lpuartClock
static const clock_ip_name_t s_lpuartClock[]
Definition fsl_lpuart.c:90

◆ LPUART0_LPUART1_RX_DriverIRQHandler()

void LPUART0_LPUART1_RX_DriverIRQHandler ( void  )

Definition at line 1579 of file fsl_lpuart.c.

1580{
1581 if (CLOCK_isEnabledClock(s_lpuartClock[0]))
1582 {
1583 if ((LPUART_STAT_OR_MASK & LPUART0->STAT) ||
1584 ((LPUART_STAT_RDRF_MASK & LPUART0->STAT) && (LPUART_CTRL_RIE_MASK & LPUART0->CTRL)))
1585 {
1586 s_lpuartIsr(LPUART0, s_lpuartHandle[0]);
1587 }
1588 }
1589 if (CLOCK_isEnabledClock(s_lpuartClock[1]))
1590 {
1591 if ((LPUART_STAT_OR_MASK & LPUART1->STAT) ||
1592 ((LPUART_STAT_RDRF_MASK & LPUART1->STAT) && (LPUART_CTRL_RIE_MASK & LPUART1->CTRL)))
1593 {
1594 s_lpuartIsr(LPUART1, s_lpuartHandle[1]);
1595 }
1596 }
1597/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1598 exception return operation might vector to incorrect interrupt */
1599#if defined __CORTEX_M && (__CORTEX_M == 4U)
1600 __DSB();
1601#endif
1602}

◆ LPUART0_LPUART1_TX_DriverIRQHandler()

void LPUART0_LPUART1_TX_DriverIRQHandler ( void  )

Definition at line 1603 of file fsl_lpuart.c.

1604{
1605 if (CLOCK_isEnabledClock(s_lpuartClock[0]))
1606 {
1607 if ((LPUART_STAT_OR_MASK & LPUART0->STAT) ||
1608 ((LPUART0->STAT & LPUART_STAT_TDRE_MASK) && (LPUART0->CTRL & LPUART_CTRL_TIE_MASK)))
1609 {
1610 s_lpuartIsr(LPUART0, s_lpuartHandle[0]);
1611 }
1612 }
1613 if (CLOCK_isEnabledClock(s_lpuartClock[1]))
1614 {
1615 if ((LPUART_STAT_OR_MASK & LPUART1->STAT) ||
1616 ((LPUART1->STAT & LPUART_STAT_TDRE_MASK) && (LPUART1->CTRL & LPUART_CTRL_TIE_MASK)))
1617 {
1618 s_lpuartIsr(LPUART1, s_lpuartHandle[1]);
1619 }
1620 }
1621/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1622 exception return operation might vector to incorrect interrupt */
1623#if defined __CORTEX_M && (__CORTEX_M == 4U)
1624 __DSB();
1625#endif
1626}

◆ LPUART0_RX_DriverIRQHandler()

void LPUART0_RX_DriverIRQHandler ( void  )

Definition at line 1669 of file fsl_lpuart.c.

1670{
1671 s_lpuartIsr(LPUART0, s_lpuartHandle[0]);
1672/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1673 exception return operation might vector to incorrect interrupt */
1674#if defined __CORTEX_M && (__CORTEX_M == 4U)
1675 __DSB();
1676#endif
1677}

◆ LPUART0_TX_DriverIRQHandler()

void LPUART0_TX_DriverIRQHandler ( void  )

Definition at line 1660 of file fsl_lpuart.c.

1661{
1662 s_lpuartIsr(LPUART0, s_lpuartHandle[0]);
1663/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1664 exception return operation might vector to incorrect interrupt */
1665#if defined __CORTEX_M && (__CORTEX_M == 4U)
1666 __DSB();
1667#endif
1668}

◆ LPUART1_DriverIRQHandler()

void LPUART1_DriverIRQHandler ( void  )

Definition at line 1714 of file fsl_lpuart.c.

1715{
1716 s_lpuartIsr(LPUART1, s_lpuartHandle[1]);
1717/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1718 exception return operation might vector to incorrect interrupt */
1719#if defined __CORTEX_M && (__CORTEX_M == 4U)
1720 __DSB();
1721#endif
1722}

◆ LPUART1_RX_DriverIRQHandler()

void LPUART1_RX_DriverIRQHandler ( void  )

Definition at line 1704 of file fsl_lpuart.c.

1705{
1706 s_lpuartIsr(LPUART1, s_lpuartHandle[1]);
1707/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1708 exception return operation might vector to incorrect interrupt */
1709#if defined __CORTEX_M && (__CORTEX_M == 4U)
1710 __DSB();
1711#endif
1712}

◆ LPUART1_TX_DriverIRQHandler()

void LPUART1_TX_DriverIRQHandler ( void  )

Definition at line 1695 of file fsl_lpuart.c.

1696{
1697 s_lpuartIsr(LPUART1, s_lpuartHandle[1]);
1698/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1699 exception return operation might vector to incorrect interrupt */
1700#if defined __CORTEX_M && (__CORTEX_M == 4U)
1701 __DSB();
1702#endif
1703}

◆ LPUART2_DriverIRQHandler()

void LPUART2_DriverIRQHandler ( void  )

Definition at line 1748 of file fsl_lpuart.c.

1749{
1750 s_lpuartIsr(LPUART2, s_lpuartHandle[2]);
1751/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1752 exception return operation might vector to incorrect interrupt */
1753#if defined __CORTEX_M && (__CORTEX_M == 4U)
1754 __DSB();
1755#endif
1756}

◆ LPUART2_RX_DriverIRQHandler()

void LPUART2_RX_DriverIRQHandler ( void  )

Definition at line 1738 of file fsl_lpuart.c.

1739{
1740 s_lpuartIsr(LPUART2, s_lpuartHandle[2]);
1741/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1742 exception return operation might vector to incorrect interrupt */
1743#if defined __CORTEX_M && (__CORTEX_M == 4U)
1744 __DSB();
1745#endif
1746}

◆ LPUART2_TX_DriverIRQHandler()

void LPUART2_TX_DriverIRQHandler ( void  )

Definition at line 1729 of file fsl_lpuart.c.

1730{
1731 s_lpuartIsr(LPUART2, s_lpuartHandle[2]);
1732/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1733 exception return operation might vector to incorrect interrupt */
1734#if defined __CORTEX_M && (__CORTEX_M == 4U)
1735 __DSB();
1736#endif
1737}

◆ LPUART3_DriverIRQHandler()

void LPUART3_DriverIRQHandler ( void  )

Definition at line 1781 of file fsl_lpuart.c.

1782{
1783 s_lpuartIsr(LPUART3, s_lpuartHandle[3]);
1784/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1785 exception return operation might vector to incorrect interrupt */
1786#if defined __CORTEX_M && (__CORTEX_M == 4U)
1787 __DSB();
1788#endif
1789}

◆ LPUART3_RX_DriverIRQHandler()

void LPUART3_RX_DriverIRQHandler ( void  )

Definition at line 1771 of file fsl_lpuart.c.

1772{
1773 s_lpuartIsr(LPUART3, s_lpuartHandle[3]);
1774/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1775 exception return operation might vector to incorrect interrupt */
1776#if defined __CORTEX_M && (__CORTEX_M == 4U)
1777 __DSB();
1778#endif
1779}

◆ LPUART3_TX_DriverIRQHandler()

void LPUART3_TX_DriverIRQHandler ( void  )

Definition at line 1762 of file fsl_lpuart.c.

1763{
1764 s_lpuartIsr(LPUART3, s_lpuartHandle[3]);
1765/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1766 exception return operation might vector to incorrect interrupt */
1767#if defined __CORTEX_M && (__CORTEX_M == 4U)
1768 __DSB();
1769#endif
1770}

◆ LPUART4_DriverIRQHandler()

void LPUART4_DriverIRQHandler ( void  )

Definition at line 1814 of file fsl_lpuart.c.

1815{
1816 s_lpuartIsr(LPUART4, s_lpuartHandle[4]);
1817/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1818 exception return operation might vector to incorrect interrupt */
1819#if defined __CORTEX_M && (__CORTEX_M == 4U)
1820 __DSB();
1821#endif
1822}

◆ LPUART4_RX_DriverIRQHandler()

void LPUART4_RX_DriverIRQHandler ( void  )

Definition at line 1804 of file fsl_lpuart.c.

1805{
1806 s_lpuartIsr(LPUART4, s_lpuartHandle[4]);
1807/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1808 exception return operation might vector to incorrect interrupt */
1809#if defined __CORTEX_M && (__CORTEX_M == 4U)
1810 __DSB();
1811#endif
1812}

◆ LPUART4_TX_DriverIRQHandler()

void LPUART4_TX_DriverIRQHandler ( void  )

Definition at line 1795 of file fsl_lpuart.c.

1796{
1797 s_lpuartIsr(LPUART4, s_lpuartHandle[4]);
1798/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1799 exception return operation might vector to incorrect interrupt */
1800#if defined __CORTEX_M && (__CORTEX_M == 4U)
1801 __DSB();
1802#endif
1803}

◆ LPUART5_DriverIRQHandler()

void LPUART5_DriverIRQHandler ( void  )

Definition at line 1847 of file fsl_lpuart.c.

1848{
1849 s_lpuartIsr(LPUART5, s_lpuartHandle[5]);
1850/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1851 exception return operation might vector to incorrect interrupt */
1852#if defined __CORTEX_M && (__CORTEX_M == 4U)
1853 __DSB();
1854#endif
1855}

◆ LPUART5_RX_DriverIRQHandler()

void LPUART5_RX_DriverIRQHandler ( void  )

Definition at line 1837 of file fsl_lpuart.c.

1838{
1839 s_lpuartIsr(LPUART5, s_lpuartHandle[5]);
1840/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1841 exception return operation might vector to incorrect interrupt */
1842#if defined __CORTEX_M && (__CORTEX_M == 4U)
1843 __DSB();
1844#endif
1845}

◆ LPUART5_TX_DriverIRQHandler()

void LPUART5_TX_DriverIRQHandler ( void  )

Definition at line 1828 of file fsl_lpuart.c.

1829{
1830 s_lpuartIsr(LPUART5, s_lpuartHandle[5]);
1831/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1832 exception return operation might vector to incorrect interrupt */
1833#if defined __CORTEX_M && (__CORTEX_M == 4U)
1834 __DSB();
1835#endif
1836}

◆ LPUART6_DriverIRQHandler()

void LPUART6_DriverIRQHandler ( void  )

Definition at line 1880 of file fsl_lpuart.c.

1881{
1882 s_lpuartIsr(LPUART6, s_lpuartHandle[6]);
1883/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1884 exception return operation might vector to incorrect interrupt */
1885#if defined __CORTEX_M && (__CORTEX_M == 4U)
1886 __DSB();
1887#endif
1888}

◆ LPUART6_RX_DriverIRQHandler()

void LPUART6_RX_DriverIRQHandler ( void  )

Definition at line 1870 of file fsl_lpuart.c.

1871{
1872 s_lpuartIsr(LPUART6, s_lpuartHandle[6]);
1873/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1874 exception return operation might vector to incorrect interrupt */
1875#if defined __CORTEX_M && (__CORTEX_M == 4U)
1876 __DSB();
1877#endif
1878}

◆ LPUART6_TX_DriverIRQHandler()

void LPUART6_TX_DriverIRQHandler ( void  )

Definition at line 1861 of file fsl_lpuart.c.

1862{
1863 s_lpuartIsr(LPUART6, s_lpuartHandle[6]);
1864/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1865 exception return operation might vector to incorrect interrupt */
1866#if defined __CORTEX_M && (__CORTEX_M == 4U)
1867 __DSB();
1868#endif
1869}

◆ LPUART7_DriverIRQHandler()

void LPUART7_DriverIRQHandler ( void  )

Definition at line 1913 of file fsl_lpuart.c.

1914{
1915 s_lpuartIsr(LPUART7, s_lpuartHandle[7]);
1916/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1917 exception return operation might vector to incorrect interrupt */
1918#if defined __CORTEX_M && (__CORTEX_M == 4U)
1919 __DSB();
1920#endif
1921}

◆ LPUART7_RX_DriverIRQHandler()

void LPUART7_RX_DriverIRQHandler ( void  )

Definition at line 1903 of file fsl_lpuart.c.

1904{
1905 s_lpuartIsr(LPUART7, s_lpuartHandle[7]);
1906/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1907 exception return operation might vector to incorrect interrupt */
1908#if defined __CORTEX_M && (__CORTEX_M == 4U)
1909 __DSB();
1910#endif
1911}

◆ LPUART7_TX_DriverIRQHandler()

void LPUART7_TX_DriverIRQHandler ( void  )

Definition at line 1894 of file fsl_lpuart.c.

1895{
1896 s_lpuartIsr(LPUART7, s_lpuartHandle[7]);
1897/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1898 exception return operation might vector to incorrect interrupt */
1899#if defined __CORTEX_M && (__CORTEX_M == 4U)
1900 __DSB();
1901#endif
1902}

◆ LPUART8_DriverIRQHandler()

void LPUART8_DriverIRQHandler ( void  )

Definition at line 1946 of file fsl_lpuart.c.

1947{
1948 s_lpuartIsr(LPUART8, s_lpuartHandle[8]);
1949/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1950 exception return operation might vector to incorrect interrupt */
1951#if defined __CORTEX_M && (__CORTEX_M == 4U)
1952 __DSB();
1953#endif
1954}

◆ LPUART8_RX_DriverIRQHandler()

void LPUART8_RX_DriverIRQHandler ( void  )

Definition at line 1936 of file fsl_lpuart.c.

1937{
1938 s_lpuartIsr(LPUART8, s_lpuartHandle[8]);
1939/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1940 exception return operation might vector to incorrect interrupt */
1941#if defined __CORTEX_M && (__CORTEX_M == 4U)
1942 __DSB();
1943#endif
1944}

◆ LPUART8_TX_DriverIRQHandler()

void LPUART8_TX_DriverIRQHandler ( void  )

Definition at line 1927 of file fsl_lpuart.c.

1928{
1929 s_lpuartIsr(LPUART8, s_lpuartHandle[8]);
1930/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1931 exception return operation might vector to incorrect interrupt */
1932#if defined __CORTEX_M && (__CORTEX_M == 4U)
1933 __DSB();
1934#endif
1935}

◆ LPUART_ReadNonBlocking()

static void LPUART_ReadNonBlocking ( LPUART_Type *  base,
uint8_t *  data,
size_t  length 
)
static

Read RX register using non-blocking method.

This function reads data from the TX register directly, upper layer must make sure the RX register is full or TX FIFO has data before calling this function.

Parameters
baseLPUART peripheral base address.
dataStart address of the buffer to store the received data.
lengthSize of the buffer.

Definition at line 185 of file fsl_lpuart.c.

186{
187 assert(data);
188
189 size_t i;
190#if defined(FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT) && FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT
191 uint32_t ctrl = base->CTRL;
192 bool isSevenDataBits =
193 ((ctrl & LPUART_CTRL_M7_MASK) || ((!(ctrl & LPUART_CTRL_M_MASK)) && (ctrl & LPUART_CTRL_PE_MASK)));
194#endif
195
196 /* The Non Blocking read data API assume user have ensured there is enough space in
197 peripheral to write. */
198 for (i = 0; i < length; i++)
199 {
200#if defined(FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT) && FSL_FEATURE_LPUART_HAS_7BIT_DATA_SUPPORT
201 if (isSevenDataBits)
202 {
203 data[i] = (base->DATA & 0x7F);
204 }
205 else
206 {
207 data[i] = base->DATA;
208 }
209#else
210 data[i] = base->DATA;
211#endif
212 }
213}

Referenced by LPUART_TransferHandleIRQ().

Here is the caller graph for this function:

◆ LPUART_TransferIsRxRingBufferFull()

static bool LPUART_TransferIsRxRingBufferFull ( LPUART_Type *  base,
lpuart_handle_t *  handle 
)
static

Check whether the RX ring buffer is full.

@userData handle LPUART handle pointer.

Return values
trueRX ring buffer is full.
falseRX ring buffer is not full.

Definition at line 153 of file fsl_lpuart.c.

154{
155 assert(handle);
156
157 bool full;
158
159 if (LPUART_TransferGetRxRingBufferLength(base, handle) == (handle->rxRingBufferSize - 1U))
160 {
161 full = true;
162 }
163 else
164 {
165 full = false;
166 }
167 return full;
168}
_lpuart_handle::rxRingBufferSize
size_t rxRingBufferSize
Definition fsl_lpuart.h:238
LPUART_TransferGetRxRingBufferLength
size_t LPUART_TransferGetRxRingBufferLength(LPUART_Type *base, lpuart_handle_t *handle)
Get the length of received data in RX ring buffer.
Definition fsl_lpuart.c:135

Referenced by LPUART_TransferHandleIRQ().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ LPUART_WriteNonBlocking()

void LPUART_WriteNonBlocking ( LPUART_Type *  base,
const uint8_t *  data,
size_t  length 
)

Write to TX register using non-blocking method.

!!!!!!!!!!!!!!!

This function writes data to the TX register directly, upper layer must make sure the TX register is empty or TX FIFO has empty room before calling this function.

Note
This function does not check whether all the data has been sent out to bus, so before disable TX, check kLPUART_TransmissionCompleteFlag to ensure the TX is finished.
Parameters
baseLPUART peripheral base address.
dataStart address of the data to write.
lengthSize of the buffer to be sent. !!!!!!!!!!!!!!!!!!!!!!!

Definition at line 171 of file fsl_lpuart.c.

172{
173 assert(data);
174
175 size_t i;
176
177 /* The Non Blocking write data API assume user have ensured there is enough space in
178 peripheral to write. */
179 for (i = 0; i < length; i++)
180 {
181 base->DATA = data[i];
182 }
183}

Referenced by LPUART_TransferHandleIRQ().

Here is the caller graph for this function:

◆ M4_0_LPUART_DriverIRQHandler()

void M4_0_LPUART_DriverIRQHandler ( void  )

Definition at line 1959 of file fsl_lpuart.c.

1960{
1961 s_lpuartIsr(CM4_0__LPUART, s_lpuartHandle[LPUART_GetInstance(CM4_0__LPUART)]);
1962/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1963 exception return operation might vector to incorrect interrupt */
1964#if defined __CORTEX_M && (__CORTEX_M == 4U)
1965 __DSB();
1966#endif
1967}
Here is the call graph for this function:

◆ M4_1_LPUART_DriverIRQHandler()

void M4_1_LPUART_DriverIRQHandler ( void  )

Definition at line 1971 of file fsl_lpuart.c.

1972{
1973 s_lpuartIsr(CM4_1__LPUART, s_lpuartHandle[LPUART_GetInstance(CM4_1__LPUART)]);
1974/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1975 exception return operation might vector to incorrect interrupt */
1976#if defined __CORTEX_M && (__CORTEX_M == 4U)
1977 __DSB();
1978#endif
1979}
Here is the call graph for this function:

◆ M4_LPUART_DriverIRQHandler()

void M4_LPUART_DriverIRQHandler ( void  )

Definition at line 1983 of file fsl_lpuart.c.

1984{
1985 s_lpuartIsr(CM4__LPUART, s_lpuartHandle[LPUART_GetInstance(CM4__LPUART)]);
1986/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1987 exception return operation might vector to incorrect interrupt */
1988#if defined __CORTEX_M && (__CORTEX_M == 4U)
1989 __DSB();
1990#endif
1991}
Here is the call graph for this function:

Variable Documentation

◆ s_lpuartBases

LPUART_Type* const s_lpuartBases[] = LPUART_BASE_PTRS
static

Definition at line 78 of file fsl_lpuart.c.

Referenced by LPUART_GetInstance().

◆ s_lpuartClock

const clock_ip_name_t s_lpuartClock[] = LPUART_CLOCKS
static

Definition at line 90 of file fsl_lpuart.c.

Referenced by LPUART0_LPUART1_DriverIRQHandler(), LPUART0_LPUART1_RX_DriverIRQHandler(), LPUART0_LPUART1_TX_DriverIRQHandler(), LPUART_Deinit(), and LPUART_Init().

◆ s_lpuartHandle

lpuart_handle_t* s_lpuartHandle[ARRAY_SIZE(s_lpuartBases)]
static

Definition at line 80 of file fsl_lpuart.c.

Referenced by ADMA_UART0_INT_DriverIRQHandler(), ADMA_UART1_INT_DriverIRQHandler(), ADMA_UART2_INT_DriverIRQHandler(), ADMA_UART3_INT_DriverIRQHandler(), DMA_UART0_INT_DriverIRQHandler(), DMA_UART1_INT_DriverIRQHandler(), DMA_UART2_INT_DriverIRQHandler(), DMA_UART3_INT_DriverIRQHandler(), DMA_UART4_INT_DriverIRQHandler(), LPUART0_DriverIRQHandler(), LPUART0_LPUART1_DriverIRQHandler(), LPUART0_LPUART1_RX_DriverIRQHandler(), LPUART0_LPUART1_TX_DriverIRQHandler(), LPUART0_RX_DriverIRQHandler(), LPUART0_TX_DriverIRQHandler(), LPUART1_DriverIRQHandler(), LPUART1_RX_DriverIRQHandler(), LPUART1_TX_DriverIRQHandler(), LPUART2_DriverIRQHandler(), LPUART2_RX_DriverIRQHandler(), LPUART2_TX_DriverIRQHandler(), LPUART3_DriverIRQHandler(), LPUART3_RX_DriverIRQHandler(), LPUART3_TX_DriverIRQHandler(), LPUART4_DriverIRQHandler(), LPUART4_RX_DriverIRQHandler(), LPUART4_TX_DriverIRQHandler(), LPUART5_DriverIRQHandler(), LPUART5_RX_DriverIRQHandler(), LPUART5_TX_DriverIRQHandler(), LPUART6_DriverIRQHandler(), LPUART6_RX_DriverIRQHandler(), LPUART6_TX_DriverIRQHandler(), LPUART7_DriverIRQHandler(), LPUART7_RX_DriverIRQHandler(), LPUART7_TX_DriverIRQHandler(), LPUART8_DriverIRQHandler(), LPUART8_RX_DriverIRQHandler(), LPUART8_TX_DriverIRQHandler(), LPUART_TransferCreateHandle(), M4_0_LPUART_DriverIRQHandler(), M4_1_LPUART_DriverIRQHandler(), and M4_LPUART_DriverIRQHandler().

◆ s_lpuartIRQ

const IRQn_Type s_lpuartIRQ[] = LPUART_RX_TX_IRQS
static

Definition at line 86 of file fsl_lpuart.c.

Referenced by LPUART_TransferCreateHandle().

◆ s_lpuartIsr

lpuart_isr_t s_lpuartIsr
static

Definition at line 100 of file fsl_lpuart.c.

Referenced by ADMA_UART0_INT_DriverIRQHandler(), ADMA_UART1_INT_DriverIRQHandler(), ADMA_UART2_INT_DriverIRQHandler(), ADMA_UART3_INT_DriverIRQHandler(), DMA_UART0_INT_DriverIRQHandler(), DMA_UART1_INT_DriverIRQHandler(), DMA_UART2_INT_DriverIRQHandler(), DMA_UART3_INT_DriverIRQHandler(), DMA_UART4_INT_DriverIRQHandler(), LPUART0_DriverIRQHandler(), LPUART0_LPUART1_DriverIRQHandler(), LPUART0_LPUART1_RX_DriverIRQHandler(), LPUART0_LPUART1_TX_DriverIRQHandler(), LPUART0_RX_DriverIRQHandler(), LPUART0_TX_DriverIRQHandler(), LPUART1_DriverIRQHandler(), LPUART1_RX_DriverIRQHandler(), LPUART1_TX_DriverIRQHandler(), LPUART2_DriverIRQHandler(), LPUART2_RX_DriverIRQHandler(), LPUART2_TX_DriverIRQHandler(), LPUART3_DriverIRQHandler(), LPUART3_RX_DriverIRQHandler(), LPUART3_TX_DriverIRQHandler(), LPUART4_DriverIRQHandler(), LPUART4_RX_DriverIRQHandler(), LPUART4_TX_DriverIRQHandler(), LPUART5_DriverIRQHandler(), LPUART5_RX_DriverIRQHandler(), LPUART5_TX_DriverIRQHandler(), LPUART6_DriverIRQHandler(), LPUART6_RX_DriverIRQHandler(), LPUART6_TX_DriverIRQHandler(), LPUART7_DriverIRQHandler(), LPUART7_RX_DriverIRQHandler(), LPUART7_TX_DriverIRQHandler(), LPUART8_DriverIRQHandler(), LPUART8_RX_DriverIRQHandler(), LPUART8_TX_DriverIRQHandler(), LPUART_TransferCreateHandle(), M4_0_LPUART_DriverIRQHandler(), M4_1_LPUART_DriverIRQHandler(), and M4_LPUART_DriverIRQHandler().

◆ s_lpuartPeriphClocks

const clock_ip_name_t s_lpuartPeriphClocks[] = LPUART_PERIPH_CLOCKS
static

Definition at line 94 of file fsl_lpuart.c.

Referenced by LPUART_Deinit(), and LPUART_Init().

◆ s_lpuartRxIRQ

const IRQn_Type s_lpuartRxIRQ[] = LPUART_RX_IRQS
static

Definition at line 83 of file fsl_lpuart.c.

Referenced by LPUART_TransferCreateHandle().

◆ s_lpuartTxIRQ

const IRQn_Type s_lpuartTxIRQ[] = LPUART_TX_IRQS
static

Definition at line 84 of file fsl_lpuart.c.

Referenced by LPUART_TransferCreateHandle().

Go to the source code of this file.

Generated on Sat Sep 27 2025 00:10:07 for rusEFI by doxygen 1.9.8