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

Functions

static uint32_t EDMA_GetInstance (DMA_Type *base)
 Get instance number for EDMA.
 
void EDMA_InstallTCD (DMA_Type *base, uint32_t channel, edma_tcd_t *tcd)
 Push content of TCD structure into hardware TCD register.
 
void EDMA_Init (DMA_Type *base, const edma_config_t *config)
 Initializes the eDMA peripheral.
 
void EDMA_Deinit (DMA_Type *base)
 Deinitializes the eDMA peripheral.
 
void EDMA_GetDefaultConfig (edma_config_t *config)
 Gets the eDMA default configuration structure.
 
void EDMA_ResetChannel (DMA_Type *base, uint32_t channel)
 Sets all TCD registers to default values.
 
void EDMA_SetTransferConfig (DMA_Type *base, uint32_t channel, const edma_transfer_config_t *config, edma_tcd_t *nextTcd)
 Configures the eDMA transfer attribute.
 
void EDMA_SetMinorOffsetConfig (DMA_Type *base, uint32_t channel, const edma_minor_offset_config_t *config)
 Configures the eDMA minor offset feature.
 
void EDMA_SetChannelLink (DMA_Type *base, uint32_t channel, edma_channel_link_type_t type, uint32_t linkedChannel)
 Sets the channel link for the eDMA transfer.
 
void EDMA_SetBandWidth (DMA_Type *base, uint32_t channel, edma_bandwidth_t bandWidth)
 Sets the bandwidth for the eDMA transfer.
 
void EDMA_SetModulo (DMA_Type *base, uint32_t channel, edma_modulo_t srcModulo, edma_modulo_t destModulo)
 Sets the source modulo and the destination modulo for the eDMA transfer.
 
void EDMA_EnableChannelInterrupts (DMA_Type *base, uint32_t channel, uint32_t mask)
 Enables the interrupt source for the eDMA transfer.
 
void EDMA_DisableChannelInterrupts (DMA_Type *base, uint32_t channel, uint32_t mask)
 Disables the interrupt source for the eDMA transfer.
 
void EDMA_TcdReset (edma_tcd_t *tcd)
 Sets all fields to default values for the TCD structure.
 
void EDMA_TcdSetTransferConfig (edma_tcd_t *tcd, const edma_transfer_config_t *config, edma_tcd_t *nextTcd)
 Configures the eDMA TCD transfer attribute.
 
void EDMA_TcdSetMinorOffsetConfig (edma_tcd_t *tcd, const edma_minor_offset_config_t *config)
 Configures the eDMA TCD minor offset feature.
 
void EDMA_TcdSetChannelLink (edma_tcd_t *tcd, edma_channel_link_type_t type, uint32_t linkedChannel)
 Sets the channel link for the eDMA TCD.
 
void EDMA_TcdSetModulo (edma_tcd_t *tcd, edma_modulo_t srcModulo, edma_modulo_t destModulo)
 Sets the source modulo and the destination modulo for the eDMA TCD.
 
void EDMA_TcdEnableInterrupts (edma_tcd_t *tcd, uint32_t mask)
 Enables the interrupt source for the eDMA TCD.
 
void EDMA_TcdDisableInterrupts (edma_tcd_t *tcd, uint32_t mask)
 Disables the interrupt source for the eDMA TCD.
 
uint32_t EDMA_GetRemainingMajorLoopCount (DMA_Type *base, uint32_t channel)
 Gets the remaining major loop count from the eDMA current channel TCD.
 
uint32_t EDMA_GetChannelStatusFlags (DMA_Type *base, uint32_t channel)
 Gets the eDMA channel status flags.
 
void EDMA_ClearChannelStatusFlags (DMA_Type *base, uint32_t channel, uint32_t mask)
 Clears the eDMA channel status flags.
 
static uint8_t Get_StartInstance (void)
 
void EDMA_CreateHandle (edma_handle_t *handle, DMA_Type *base, uint32_t channel)
 Creates the eDMA handle.
 
void EDMA_InstallTCDMemory (edma_handle_t *handle, edma_tcd_t *tcdPool, uint32_t tcdSize)
 Installs the TCDs memory pool into the eDMA handle.
 
void EDMA_SetCallback (edma_handle_t *handle, edma_callback callback, void *userData)
 Installs a callback function for the eDMA transfer.
 
void EDMA_PrepareTransfer (edma_transfer_config_t *config, void *srcAddr, uint32_t srcWidth, void *destAddr, uint32_t destWidth, uint32_t bytesEachRequest, uint32_t transferBytes, edma_transfer_type_t type)
 Prepares the eDMA transfer structure.
 
status_t EDMA_SubmitTransfer (edma_handle_t *handle, const edma_transfer_config_t *config)
 Submits the eDMA transfer request.
 
void EDMA_StartTransfer (edma_handle_t *handle)
 eDMA starts transfer.
 
void EDMA_StopTransfer (edma_handle_t *handle)
 eDMA stops transfer.
 
void EDMA_AbortTransfer (edma_handle_t *handle)
 eDMA aborts transfer.
 
void EDMA_HandleIRQ (edma_handle_t *handle)
 eDMA IRQ handler for the current major loop transfer completion.
 
void DMA0_04_DriverIRQHandler (void)
 
void DMA0_15_DriverIRQHandler (void)
 
void DMA0_26_DriverIRQHandler (void)
 
void DMA0_37_DriverIRQHandler (void)
 
void DMA1_04_DriverIRQHandler (void)
 
void DMA1_15_DriverIRQHandler (void)
 
void DMA1_26_DriverIRQHandler (void)
 
void DMA1_37_DriverIRQHandler (void)
 
void DMA0_08_DriverIRQHandler (void)
 
void DMA0_19_DriverIRQHandler (void)
 
void DMA0_210_DriverIRQHandler (void)
 
void DMA0_311_DriverIRQHandler (void)
 
void DMA0_412_DriverIRQHandler (void)
 
void DMA0_513_DriverIRQHandler (void)
 
void DMA0_614_DriverIRQHandler (void)
 
void DMA0_715_DriverIRQHandler (void)
 
void DMA1_08_DriverIRQHandler (void)
 
void DMA1_19_DriverIRQHandler (void)
 
void DMA1_210_DriverIRQHandler (void)
 
void DMA1_311_DriverIRQHandler (void)
 
void DMA1_412_DriverIRQHandler (void)
 
void DMA1_513_DriverIRQHandler (void)
 
void DMA1_614_DriverIRQHandler (void)
 
void DMA1_715_DriverIRQHandler (void)
 
void DMA0_DMA16_DriverIRQHandler (void)
 
void DMA1_DMA17_DriverIRQHandler (void)
 
void DMA2_DMA18_DriverIRQHandler (void)
 
void DMA3_DMA19_DriverIRQHandler (void)
 
void DMA4_DMA20_DriverIRQHandler (void)
 
void DMA5_DMA21_DriverIRQHandler (void)
 
void DMA6_DMA22_DriverIRQHandler (void)
 
void DMA7_DMA23_DriverIRQHandler (void)
 
void DMA8_DMA24_DriverIRQHandler (void)
 
void DMA9_DMA25_DriverIRQHandler (void)
 
void DMA10_DMA26_DriverIRQHandler (void)
 
void DMA11_DMA27_DriverIRQHandler (void)
 
void DMA12_DMA28_DriverIRQHandler (void)
 
void DMA13_DMA29_DriverIRQHandler (void)
 
void DMA14_DMA30_DriverIRQHandler (void)
 
void DMA15_DMA31_DriverIRQHandler (void)
 
void DMA0_0_4_DriverIRQHandler (void)
 
void DMA0_1_5_DriverIRQHandler (void)
 
void DMA0_2_6_DriverIRQHandler (void)
 
void DMA0_3_7_DriverIRQHandler (void)
 
void DMA0_8_12_DriverIRQHandler (void)
 
void DMA0_9_13_DriverIRQHandler (void)
 
void DMA0_10_14_DriverIRQHandler (void)
 
void DMA0_11_15_DriverIRQHandler (void)
 
void DMA0_16_20_DriverIRQHandler (void)
 
void DMA0_17_21_DriverIRQHandler (void)
 
void DMA0_18_22_DriverIRQHandler (void)
 
void DMA0_19_23_DriverIRQHandler (void)
 
void DMA0_24_28_DriverIRQHandler (void)
 
void DMA0_25_29_DriverIRQHandler (void)
 
void DMA0_26_30_DriverIRQHandler (void)
 
void DMA0_27_31_DriverIRQHandler (void)
 
void DMA0_DriverIRQHandler (void)
 
void DMA1_DriverIRQHandler (void)
 
void DMA2_DriverIRQHandler (void)
 
void DMA3_DriverIRQHandler (void)
 
void DMA4_DriverIRQHandler (void)
 
void DMA5_DriverIRQHandler (void)
 
void DMA6_DriverIRQHandler (void)
 
void DMA7_DriverIRQHandler (void)
 
void DMA8_DriverIRQHandler (void)
 
void DMA9_DriverIRQHandler (void)
 
void DMA10_DriverIRQHandler (void)
 
void DMA11_DriverIRQHandler (void)
 
void DMA12_DriverIRQHandler (void)
 
void DMA13_DriverIRQHandler (void)
 
void DMA14_DriverIRQHandler (void)
 
void DMA15_DriverIRQHandler (void)
 
void DMA16_DriverIRQHandler (void)
 
void DMA17_DriverIRQHandler (void)
 
void DMA18_DriverIRQHandler (void)
 
void DMA19_DriverIRQHandler (void)
 
void DMA20_DriverIRQHandler (void)
 
void DMA21_DriverIRQHandler (void)
 
void DMA22_DriverIRQHandler (void)
 
void DMA23_DriverIRQHandler (void)
 
void DMA24_DriverIRQHandler (void)
 
void DMA25_DriverIRQHandler (void)
 
void DMA26_DriverIRQHandler (void)
 
void DMA27_DriverIRQHandler (void)
 
void DMA28_DriverIRQHandler (void)
 
void DMA29_DriverIRQHandler (void)
 
void DMA30_DriverIRQHandler (void)
 
void DMA31_DriverIRQHandler (void)
 

Variables

static DMA_Type *const s_edmaBases [] = DMA_BASE_PTRS
 Array to map EDMA instance number to base pointer.
 
static const clock_ip_name_t s_edmaClockName [] = EDMA_CLOCKS
 Array to map EDMA instance number to clock name.
 
static const IRQn_Type s_edmaIRQNumber [][FSL_FEATURE_EDMA_MODULE_CHANNEL] = DMA_CHN_IRQS
 Array to map EDMA instance number to IRQ number.
 
static edma_handle_t * s_EDMAHandle [FSL_FEATURE_EDMA_MODULE_CHANNEL *FSL_FEATURE_SOC_EDMA_COUNT]
 Pointers to transfer handle for each EDMA channel.
 

Function Documentation

◆ DMA0_04_DriverIRQHandler()

void DMA0_04_DriverIRQHandler ( void  )

Definition at line 1298 of file fsl_edma.c.

1299{
1300 if ((EDMA_GetChannelStatusFlags(DMA0, 0U) & kEDMA_InterruptFlag) != 0U)
1301 {
1302 EDMA_HandleIRQ(s_EDMAHandle[0]);
1303 }
1304 if ((EDMA_GetChannelStatusFlags(DMA0, 4U) & kEDMA_InterruptFlag) != 0U)
1305 {
1306 EDMA_HandleIRQ(s_EDMAHandle[4]);
1307 }
1308/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1309 exception return operation might vector to incorrect interrupt */
1310#if defined __CORTEX_M && (__CORTEX_M == 4U)
1311 __DSB();
1312#endif
1313}
s_EDMAHandle
static edma_handle_t * s_EDMAHandle[FSL_FEATURE_EDMA_MODULE_CHANNEL *FSL_FEATURE_SOC_EDMA_COUNT]
Pointers to transfer handle for each EDMA channel.
Definition fsl_edma.c:50
EDMA_GetChannelStatusFlags
uint32_t EDMA_GetChannelStatusFlags(DMA_Type *base, uint32_t channel)
Gets the eDMA channel status flags.
Definition fsl_edma.c:684
EDMA_HandleIRQ
void EDMA_HandleIRQ(edma_handle_t *handle)
eDMA IRQ handler for the current major loop transfer completion.
Definition fsl_edma.c:1213
kEDMA_InterruptFlag
@ kEDMA_InterruptFlag
Definition fsl_edma.h:104
Here is the call graph for this function:

◆ DMA0_08_DriverIRQHandler()

void DMA0_08_DriverIRQHandler ( void  )

Definition at line 1513 of file fsl_edma.c.

1514{
1515 if ((EDMA_GetChannelStatusFlags(DMA0, 0U) & kEDMA_InterruptFlag) != 0U)
1516 {
1517 EDMA_HandleIRQ(s_EDMAHandle[0]);
1518 }
1519 if ((EDMA_GetChannelStatusFlags(DMA0, 8U) & kEDMA_InterruptFlag) != 0U)
1520 {
1521 EDMA_HandleIRQ(s_EDMAHandle[8]);
1522 }
1523/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1524 exception return operation might vector to incorrect interrupt */
1525#if defined __CORTEX_M && (__CORTEX_M == 4U)
1526 __DSB();
1527#endif
1528}
Here is the call graph for this function:

◆ DMA0_0_4_DriverIRQHandler()

void DMA0_0_4_DriverIRQHandler ( void  )

Definition at line 2067 of file fsl_edma.c.

2068{
2069 if ((EDMA_GetChannelStatusFlags(DMA0, 0U) & kEDMA_InterruptFlag) != 0U)
2070 {
2071 EDMA_HandleIRQ(s_EDMAHandle[0]);
2072 }
2073 if ((EDMA_GetChannelStatusFlags(DMA0, 4U) & kEDMA_InterruptFlag) != 0U)
2074 {
2075 EDMA_HandleIRQ(s_EDMAHandle[4]);
2076 }
2077/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2078 exception return operation might vector to incorrect interrupt */
2079#if defined __CORTEX_M && (__CORTEX_M == 4U)
2080 __DSB();
2081#endif
2082}
Here is the call graph for this function:

◆ DMA0_10_14_DriverIRQHandler()

void DMA0_10_14_DriverIRQHandler ( void  )

Definition at line 2169 of file fsl_edma.c.

2170{
2171 if ((EDMA_GetChannelStatusFlags(DMA0, 10U) & kEDMA_InterruptFlag) != 0U)
2172 {
2173 EDMA_HandleIRQ(s_EDMAHandle[10]);
2174 }
2175 if ((EDMA_GetChannelStatusFlags(DMA0, 14U) & kEDMA_InterruptFlag) != 0U)
2176 {
2177 EDMA_HandleIRQ(s_EDMAHandle[14]);
2178 }
2179/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2180 exception return operation might vector to incorrect interrupt */
2181#if defined __CORTEX_M && (__CORTEX_M == 4U)
2182 __DSB();
2183#endif
2184}
Here is the call graph for this function:

◆ DMA0_11_15_DriverIRQHandler()

void DMA0_11_15_DriverIRQHandler ( void  )

Definition at line 2186 of file fsl_edma.c.

2187{
2188 if ((EDMA_GetChannelStatusFlags(DMA0, 11U) & kEDMA_InterruptFlag) != 0U)
2189 {
2190 EDMA_HandleIRQ(s_EDMAHandle[11]);
2191 }
2192 if ((EDMA_GetChannelStatusFlags(DMA0, 15U) & kEDMA_InterruptFlag) != 0U)
2193 {
2194 EDMA_HandleIRQ(s_EDMAHandle[15]);
2195 }
2196/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2197 exception return operation might vector to incorrect interrupt */
2198#if defined __CORTEX_M && (__CORTEX_M == 4U)
2199 __DSB();
2200#endif
2201}
Here is the call graph for this function:

◆ DMA0_15_DriverIRQHandler()

void DMA0_15_DriverIRQHandler ( void  )

Definition at line 1315 of file fsl_edma.c.

1316{
1317 if ((EDMA_GetChannelStatusFlags(DMA0, 1U) & kEDMA_InterruptFlag) != 0U)
1318 {
1319 EDMA_HandleIRQ(s_EDMAHandle[1]);
1320 }
1321 if ((EDMA_GetChannelStatusFlags(DMA0, 5U) & kEDMA_InterruptFlag) != 0U)
1322 {
1323 EDMA_HandleIRQ(s_EDMAHandle[5]);
1324 }
1325/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1326 exception return operation might vector to incorrect interrupt */
1327#if defined __CORTEX_M && (__CORTEX_M == 4U)
1328 __DSB();
1329#endif
1330}
Here is the call graph for this function:

◆ DMA0_16_20_DriverIRQHandler()

void DMA0_16_20_DriverIRQHandler ( void  )

Definition at line 2203 of file fsl_edma.c.

2204{
2205 if ((EDMA_GetChannelStatusFlags(DMA0, 16U) & kEDMA_InterruptFlag) != 0U)
2206 {
2207 EDMA_HandleIRQ(s_EDMAHandle[16]);
2208 }
2209 if ((EDMA_GetChannelStatusFlags(DMA0, 20U) & kEDMA_InterruptFlag) != 0U)
2210 {
2211 EDMA_HandleIRQ(s_EDMAHandle[20]);
2212 }
2213/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2214 exception return operation might vector to incorrect interrupt */
2215#if defined __CORTEX_M && (__CORTEX_M == 4U)
2216 __DSB();
2217#endif
2218}
Here is the call graph for this function:

◆ DMA0_17_21_DriverIRQHandler()

void DMA0_17_21_DriverIRQHandler ( void  )

Definition at line 2220 of file fsl_edma.c.

2221{
2222 if ((EDMA_GetChannelStatusFlags(DMA0, 17U) & kEDMA_InterruptFlag) != 0U)
2223 {
2224 EDMA_HandleIRQ(s_EDMAHandle[17]);
2225 }
2226 if ((EDMA_GetChannelStatusFlags(DMA0, 21U) & kEDMA_InterruptFlag) != 0U)
2227 {
2228 EDMA_HandleIRQ(s_EDMAHandle[21]);
2229 }
2230/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2231 exception return operation might vector to incorrect interrupt */
2232#if defined __CORTEX_M && (__CORTEX_M == 4U)
2233 __DSB();
2234#endif
2235}
Here is the call graph for this function:

◆ DMA0_18_22_DriverIRQHandler()

void DMA0_18_22_DriverIRQHandler ( void  )

Definition at line 2237 of file fsl_edma.c.

2238{
2239 if ((EDMA_GetChannelStatusFlags(DMA0, 18U) & kEDMA_InterruptFlag) != 0U)
2240 {
2241 EDMA_HandleIRQ(s_EDMAHandle[18]);
2242 }
2243 if ((EDMA_GetChannelStatusFlags(DMA0, 22U) & kEDMA_InterruptFlag) != 0U)
2244 {
2245 EDMA_HandleIRQ(s_EDMAHandle[22]);
2246 }
2247/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2248 exception return operation might vector to incorrect interrupt */
2249#if defined __CORTEX_M && (__CORTEX_M == 4U)
2250 __DSB();
2251#endif
2252}
Here is the call graph for this function:

◆ DMA0_19_23_DriverIRQHandler()

void DMA0_19_23_DriverIRQHandler ( void  )

Definition at line 2254 of file fsl_edma.c.

2255{
2256 if ((EDMA_GetChannelStatusFlags(DMA0, 19U) & kEDMA_InterruptFlag) != 0U)
2257 {
2258 EDMA_HandleIRQ(s_EDMAHandle[19]);
2259 }
2260 if ((EDMA_GetChannelStatusFlags(DMA0, 23U) & kEDMA_InterruptFlag) != 0U)
2261 {
2262 EDMA_HandleIRQ(s_EDMAHandle[23]);
2263 }
2264/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2265 exception return operation might vector to incorrect interrupt */
2266#if defined __CORTEX_M && (__CORTEX_M == 4U)
2267 __DSB();
2268#endif
2269}
Here is the call graph for this function:

◆ DMA0_19_DriverIRQHandler()

void DMA0_19_DriverIRQHandler ( void  )

Definition at line 1530 of file fsl_edma.c.

1531{
1532 if ((EDMA_GetChannelStatusFlags(DMA0, 1U) & kEDMA_InterruptFlag) != 0U)
1533 {
1534 EDMA_HandleIRQ(s_EDMAHandle[1]);
1535 }
1536 if ((EDMA_GetChannelStatusFlags(DMA0, 9U) & kEDMA_InterruptFlag) != 0U)
1537 {
1538 EDMA_HandleIRQ(s_EDMAHandle[9]);
1539 }
1540/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1541 exception return operation might vector to incorrect interrupt */
1542#if defined __CORTEX_M && (__CORTEX_M == 4U)
1543 __DSB();
1544#endif
1545}
Here is the call graph for this function:

◆ DMA0_1_5_DriverIRQHandler()

void DMA0_1_5_DriverIRQHandler ( void  )

Definition at line 2084 of file fsl_edma.c.

2085{
2086 if ((EDMA_GetChannelStatusFlags(DMA0, 1U) & kEDMA_InterruptFlag) != 0U)
2087 {
2088 EDMA_HandleIRQ(s_EDMAHandle[1]);
2089 }
2090 if ((EDMA_GetChannelStatusFlags(DMA0, 5U) & kEDMA_InterruptFlag) != 0U)
2091 {
2092 EDMA_HandleIRQ(s_EDMAHandle[5]);
2093 }
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:

◆ DMA0_210_DriverIRQHandler()

void DMA0_210_DriverIRQHandler ( void  )

Definition at line 1547 of file fsl_edma.c.

1548{
1549 if ((EDMA_GetChannelStatusFlags(DMA0, 2U) & kEDMA_InterruptFlag) != 0U)
1550 {
1551 EDMA_HandleIRQ(s_EDMAHandle[2]);
1552 }
1553 if ((EDMA_GetChannelStatusFlags(DMA0, 10U) & kEDMA_InterruptFlag) != 0U)
1554 {
1555 EDMA_HandleIRQ(s_EDMAHandle[10]);
1556 }
1557/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1558 exception return operation might vector to incorrect interrupt */
1559#if defined __CORTEX_M && (__CORTEX_M == 4U)
1560 __DSB();
1561#endif
1562}
Here is the call graph for this function:

◆ DMA0_24_28_DriverIRQHandler()

void DMA0_24_28_DriverIRQHandler ( void  )

Definition at line 2271 of file fsl_edma.c.

2272{
2273 if ((EDMA_GetChannelStatusFlags(DMA0, 24U) & kEDMA_InterruptFlag) != 0U)
2274 {
2275 EDMA_HandleIRQ(s_EDMAHandle[24]);
2276 }
2277 if ((EDMA_GetChannelStatusFlags(DMA0, 28U) & kEDMA_InterruptFlag) != 0U)
2278 {
2279 EDMA_HandleIRQ(s_EDMAHandle[28]);
2280 }
2281/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2282 exception return operation might vector to incorrect interrupt */
2283#if defined __CORTEX_M && (__CORTEX_M == 4U)
2284 __DSB();
2285#endif
2286}
Here is the call graph for this function:

◆ DMA0_25_29_DriverIRQHandler()

void DMA0_25_29_DriverIRQHandler ( void  )

Definition at line 2288 of file fsl_edma.c.

2289{
2290 if ((EDMA_GetChannelStatusFlags(DMA0, 25U) & kEDMA_InterruptFlag) != 0U)
2291 {
2292 EDMA_HandleIRQ(s_EDMAHandle[25]);
2293 }
2294 if ((EDMA_GetChannelStatusFlags(DMA0, 29U) & kEDMA_InterruptFlag) != 0U)
2295 {
2296 EDMA_HandleIRQ(s_EDMAHandle[29]);
2297 }
2298/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2299 exception return operation might vector to incorrect interrupt */
2300#if defined __CORTEX_M && (__CORTEX_M == 4U)
2301 __DSB();
2302#endif
2303}
Here is the call graph for this function:

◆ DMA0_26_30_DriverIRQHandler()

void DMA0_26_30_DriverIRQHandler ( void  )

Definition at line 2305 of file fsl_edma.c.

2306{
2307 if ((EDMA_GetChannelStatusFlags(DMA0, 26U) & kEDMA_InterruptFlag) != 0U)
2308 {
2309 EDMA_HandleIRQ(s_EDMAHandle[26]);
2310 }
2311 if ((EDMA_GetChannelStatusFlags(DMA0, 30U) & kEDMA_InterruptFlag) != 0U)
2312 {
2313 EDMA_HandleIRQ(s_EDMAHandle[30]);
2314 }
2315/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2316 exception return operation might vector to incorrect interrupt */
2317#if defined __CORTEX_M && (__CORTEX_M == 4U)
2318 __DSB();
2319#endif
2320}
Here is the call graph for this function:

◆ DMA0_26_DriverIRQHandler()

void DMA0_26_DriverIRQHandler ( void  )

Definition at line 1332 of file fsl_edma.c.

1333{
1334 if ((EDMA_GetChannelStatusFlags(DMA0, 2U) & kEDMA_InterruptFlag) != 0U)
1335 {
1336 EDMA_HandleIRQ(s_EDMAHandle[2]);
1337 }
1338 if ((EDMA_GetChannelStatusFlags(DMA0, 6U) & kEDMA_InterruptFlag) != 0U)
1339 {
1340 EDMA_HandleIRQ(s_EDMAHandle[6]);
1341 }
1342/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1343 exception return operation might vector to incorrect interrupt */
1344#if defined __CORTEX_M && (__CORTEX_M == 4U)
1345 __DSB();
1346#endif
1347}
Here is the call graph for this function:

◆ DMA0_27_31_DriverIRQHandler()

void DMA0_27_31_DriverIRQHandler ( void  )

Definition at line 2322 of file fsl_edma.c.

2323{
2324 if ((EDMA_GetChannelStatusFlags(DMA0, 27U) & kEDMA_InterruptFlag) != 0U)
2325 {
2326 EDMA_HandleIRQ(s_EDMAHandle[27]);
2327 }
2328 if ((EDMA_GetChannelStatusFlags(DMA0, 31U) & kEDMA_InterruptFlag) != 0U)
2329 {
2330 EDMA_HandleIRQ(s_EDMAHandle[31]);
2331 }
2332/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2333 exception return operation might vector to incorrect interrupt */
2334#if defined __CORTEX_M && (__CORTEX_M == 4U)
2335 __DSB();
2336#endif
2337}
Here is the call graph for this function:

◆ DMA0_2_6_DriverIRQHandler()

void DMA0_2_6_DriverIRQHandler ( void  )

Definition at line 2101 of file fsl_edma.c.

2102{
2103 if ((EDMA_GetChannelStatusFlags(DMA0, 2U) & kEDMA_InterruptFlag) != 0U)
2104 {
2105 EDMA_HandleIRQ(s_EDMAHandle[2]);
2106 }
2107 if ((EDMA_GetChannelStatusFlags(DMA0, 6U) & kEDMA_InterruptFlag) != 0U)
2108 {
2109 EDMA_HandleIRQ(s_EDMAHandle[6]);
2110 }
2111/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2112 exception return operation might vector to incorrect interrupt */
2113#if defined __CORTEX_M && (__CORTEX_M == 4U)
2114 __DSB();
2115#endif
2116}
Here is the call graph for this function:

◆ DMA0_311_DriverIRQHandler()

void DMA0_311_DriverIRQHandler ( void  )

Definition at line 1564 of file fsl_edma.c.

1565{
1566 if ((EDMA_GetChannelStatusFlags(DMA0, 3U) & kEDMA_InterruptFlag) != 0U)
1567 {
1568 EDMA_HandleIRQ(s_EDMAHandle[3]);
1569 }
1570 if ((EDMA_GetChannelStatusFlags(DMA0, 11U) & kEDMA_InterruptFlag) != 0U)
1571 {
1572 EDMA_HandleIRQ(s_EDMAHandle[11]);
1573 }
1574/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1575 exception return operation might vector to incorrect interrupt */
1576#if defined __CORTEX_M && (__CORTEX_M == 4U)
1577 __DSB();
1578#endif
1579}
Here is the call graph for this function:

◆ DMA0_37_DriverIRQHandler()

void DMA0_37_DriverIRQHandler ( void  )

Definition at line 1349 of file fsl_edma.c.

1350{
1351 if ((EDMA_GetChannelStatusFlags(DMA0, 3U) & kEDMA_InterruptFlag) != 0U)
1352 {
1353 EDMA_HandleIRQ(s_EDMAHandle[3]);
1354 }
1355 if ((EDMA_GetChannelStatusFlags(DMA0, 7U) & kEDMA_InterruptFlag) != 0U)
1356 {
1357 EDMA_HandleIRQ(s_EDMAHandle[7]);
1358 }
1359/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1360 exception return operation might vector to incorrect interrupt */
1361#if defined __CORTEX_M && (__CORTEX_M == 4U)
1362 __DSB();
1363#endif
1364}
Here is the call graph for this function:

◆ DMA0_3_7_DriverIRQHandler()

void DMA0_3_7_DriverIRQHandler ( void  )

Definition at line 2118 of file fsl_edma.c.

2119{
2120 if ((EDMA_GetChannelStatusFlags(DMA0, 3U) & kEDMA_InterruptFlag) != 0U)
2121 {
2122 EDMA_HandleIRQ(s_EDMAHandle[3]);
2123 }
2124 if ((EDMA_GetChannelStatusFlags(DMA0, 7U) & kEDMA_InterruptFlag) != 0U)
2125 {
2126 EDMA_HandleIRQ(s_EDMAHandle[7]);
2127 }
2128/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2129 exception return operation might vector to incorrect interrupt */
2130#if defined __CORTEX_M && (__CORTEX_M == 4U)
2131 __DSB();
2132#endif
2133}
Here is the call graph for this function:

◆ DMA0_412_DriverIRQHandler()

void DMA0_412_DriverIRQHandler ( void  )

Definition at line 1581 of file fsl_edma.c.

1582{
1583 if ((EDMA_GetChannelStatusFlags(DMA0, 4U) & kEDMA_InterruptFlag) != 0U)
1584 {
1585 EDMA_HandleIRQ(s_EDMAHandle[4]);
1586 }
1587 if ((EDMA_GetChannelStatusFlags(DMA0, 12U) & kEDMA_InterruptFlag) != 0U)
1588 {
1589 EDMA_HandleIRQ(s_EDMAHandle[12]);
1590 }
1591/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1592 exception return operation might vector to incorrect interrupt */
1593#if defined __CORTEX_M && (__CORTEX_M == 4U)
1594 __DSB();
1595#endif
1596}
Here is the call graph for this function:

◆ DMA0_513_DriverIRQHandler()

void DMA0_513_DriverIRQHandler ( void  )

Definition at line 1598 of file fsl_edma.c.

1599{
1600 if ((EDMA_GetChannelStatusFlags(DMA0, 5U) & kEDMA_InterruptFlag) != 0U)
1601 {
1602 EDMA_HandleIRQ(s_EDMAHandle[5]);
1603 }
1604 if ((EDMA_GetChannelStatusFlags(DMA0, 13U) & kEDMA_InterruptFlag) != 0U)
1605 {
1606 EDMA_HandleIRQ(s_EDMAHandle[13]);
1607 }
1608/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1609 exception return operation might vector to incorrect interrupt */
1610#if defined __CORTEX_M && (__CORTEX_M == 4U)
1611 __DSB();
1612#endif
1613}
Here is the call graph for this function:

◆ DMA0_614_DriverIRQHandler()

void DMA0_614_DriverIRQHandler ( void  )

Definition at line 1615 of file fsl_edma.c.

1616{
1617 if ((EDMA_GetChannelStatusFlags(DMA0, 6U) & kEDMA_InterruptFlag) != 0U)
1618 {
1619 EDMA_HandleIRQ(s_EDMAHandle[6]);
1620 }
1621 if ((EDMA_GetChannelStatusFlags(DMA0, 14U) & kEDMA_InterruptFlag) != 0U)
1622 {
1623 EDMA_HandleIRQ(s_EDMAHandle[14]);
1624 }
1625/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1626 exception return operation might vector to incorrect interrupt */
1627#if defined __CORTEX_M && (__CORTEX_M == 4U)
1628 __DSB();
1629#endif
1630}
Here is the call graph for this function:

◆ DMA0_715_DriverIRQHandler()

void DMA0_715_DriverIRQHandler ( void  )

Definition at line 1632 of file fsl_edma.c.

1633{
1634 if ((EDMA_GetChannelStatusFlags(DMA0, 7U) & kEDMA_InterruptFlag) != 0U)
1635 {
1636 EDMA_HandleIRQ(s_EDMAHandle[7]);
1637 }
1638 if ((EDMA_GetChannelStatusFlags(DMA0, 15U) & kEDMA_InterruptFlag) != 0U)
1639 {
1640 EDMA_HandleIRQ(s_EDMAHandle[15]);
1641 }
1642/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1643 exception return operation might vector to incorrect interrupt */
1644#if defined __CORTEX_M && (__CORTEX_M == 4U)
1645 __DSB();
1646#endif
1647}
Here is the call graph for this function:

◆ DMA0_8_12_DriverIRQHandler()

void DMA0_8_12_DriverIRQHandler ( void  )

Definition at line 2135 of file fsl_edma.c.

2136{
2137 if ((EDMA_GetChannelStatusFlags(DMA0, 8U) & kEDMA_InterruptFlag) != 0U)
2138 {
2139 EDMA_HandleIRQ(s_EDMAHandle[8]);
2140 }
2141 if ((EDMA_GetChannelStatusFlags(DMA0, 12U) & kEDMA_InterruptFlag) != 0U)
2142 {
2143 EDMA_HandleIRQ(s_EDMAHandle[12]);
2144 }
2145/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2146 exception return operation might vector to incorrect interrupt */
2147#if defined __CORTEX_M && (__CORTEX_M == 4U)
2148 __DSB();
2149#endif
2150}
Here is the call graph for this function:

◆ DMA0_9_13_DriverIRQHandler()

void DMA0_9_13_DriverIRQHandler ( void  )

Definition at line 2152 of file fsl_edma.c.

2153{
2154 if ((EDMA_GetChannelStatusFlags(DMA0, 9U) & kEDMA_InterruptFlag) != 0U)
2155 {
2156 EDMA_HandleIRQ(s_EDMAHandle[9]);
2157 }
2158 if ((EDMA_GetChannelStatusFlags(DMA0, 13U) & kEDMA_InterruptFlag) != 0U)
2159 {
2160 EDMA_HandleIRQ(s_EDMAHandle[13]);
2161 }
2162/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2163 exception return operation might vector to incorrect interrupt */
2164#if defined __CORTEX_M && (__CORTEX_M == 4U)
2165 __DSB();
2166#endif
2167}
Here is the call graph for this function:

◆ DMA0_DMA16_DriverIRQHandler()

void DMA0_DMA16_DriverIRQHandler ( void  )

Definition at line 1791 of file fsl_edma.c.

1792{
1793 if ((EDMA_GetChannelStatusFlags(DMA0, 0U) & kEDMA_InterruptFlag) != 0U)
1794 {
1795 EDMA_HandleIRQ(s_EDMAHandle[0]);
1796 }
1797 if ((EDMA_GetChannelStatusFlags(DMA0, 16U) & kEDMA_InterruptFlag) != 0U)
1798 {
1799 EDMA_HandleIRQ(s_EDMAHandle[16]);
1800 }
1801/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1802 exception return operation might vector to incorrect interrupt */
1803#if defined __CORTEX_M && (__CORTEX_M == 4U)
1804 __DSB();
1805#endif
1806}
Here is the call graph for this function:

◆ DMA0_DriverIRQHandler()

void DMA0_DriverIRQHandler ( void  )

Definition at line 2343 of file fsl_edma.c.

2344{
2345 EDMA_HandleIRQ(s_EDMAHandle[0]);
2346/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2347 exception return operation might vector to incorrect interrupt */
2348#if defined __CORTEX_M && (__CORTEX_M == 4U)
2349 __DSB();
2350#endif
2351}
Here is the call graph for this function:

◆ DMA10_DMA26_DriverIRQHandler()

void DMA10_DMA26_DriverIRQHandler ( void  )

Definition at line 1961 of file fsl_edma.c.

1962{
1963 if ((EDMA_GetChannelStatusFlags(DMA0, 10U) & kEDMA_InterruptFlag) != 0U)
1964 {
1965 EDMA_HandleIRQ(s_EDMAHandle[10]);
1966 }
1967 if ((EDMA_GetChannelStatusFlags(DMA0, 26U) & kEDMA_InterruptFlag) != 0U)
1968 {
1969 EDMA_HandleIRQ(s_EDMAHandle[26]);
1970 }
1971/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1972 exception return operation might vector to incorrect interrupt */
1973#if defined __CORTEX_M && (__CORTEX_M == 4U)
1974 __DSB();
1975#endif
1976}
Here is the call graph for this function:

◆ DMA10_DriverIRQHandler()

void DMA10_DriverIRQHandler ( void  )

Definition at line 2450 of file fsl_edma.c.

2451{
2452 EDMA_HandleIRQ(s_EDMAHandle[10]);
2453/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2454 exception return operation might vector to incorrect interrupt */
2455#if defined __CORTEX_M && (__CORTEX_M == 4U)
2456 __DSB();
2457#endif
2458}
Here is the call graph for this function:

◆ DMA11_DMA27_DriverIRQHandler()

void DMA11_DMA27_DriverIRQHandler ( void  )

Definition at line 1978 of file fsl_edma.c.

1979{
1980 if ((EDMA_GetChannelStatusFlags(DMA0, 11U) & kEDMA_InterruptFlag) != 0U)
1981 {
1982 EDMA_HandleIRQ(s_EDMAHandle[11]);
1983 }
1984 if ((EDMA_GetChannelStatusFlags(DMA0, 27U) & kEDMA_InterruptFlag) != 0U)
1985 {
1986 EDMA_HandleIRQ(s_EDMAHandle[27]);
1987 }
1988/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1989 exception return operation might vector to incorrect interrupt */
1990#if defined __CORTEX_M && (__CORTEX_M == 4U)
1991 __DSB();
1992#endif
1993}
Here is the call graph for this function:

◆ DMA11_DriverIRQHandler()

void DMA11_DriverIRQHandler ( void  )

Definition at line 2460 of file fsl_edma.c.

2461{
2462 EDMA_HandleIRQ(s_EDMAHandle[11]);
2463/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2464 exception return operation might vector to incorrect interrupt */
2465#if defined __CORTEX_M && (__CORTEX_M == 4U)
2466 __DSB();
2467#endif
2468}
Here is the call graph for this function:

◆ DMA12_DMA28_DriverIRQHandler()

void DMA12_DMA28_DriverIRQHandler ( void  )

Definition at line 1995 of file fsl_edma.c.

1996{
1997 if ((EDMA_GetChannelStatusFlags(DMA0, 12U) & kEDMA_InterruptFlag) != 0U)
1998 {
1999 EDMA_HandleIRQ(s_EDMAHandle[12]);
2000 }
2001 if ((EDMA_GetChannelStatusFlags(DMA0, 28U) & kEDMA_InterruptFlag) != 0U)
2002 {
2003 EDMA_HandleIRQ(s_EDMAHandle[28]);
2004 }
2005/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2006 exception return operation might vector to incorrect interrupt */
2007#if defined __CORTEX_M && (__CORTEX_M == 4U)
2008 __DSB();
2009#endif
2010}
Here is the call graph for this function:

◆ DMA12_DriverIRQHandler()

void DMA12_DriverIRQHandler ( void  )

Definition at line 2470 of file fsl_edma.c.

2471{
2472 EDMA_HandleIRQ(s_EDMAHandle[12]);
2473/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2474 exception return operation might vector to incorrect interrupt */
2475#if defined __CORTEX_M && (__CORTEX_M == 4U)
2476 __DSB();
2477#endif
2478}
Here is the call graph for this function:

◆ DMA13_DMA29_DriverIRQHandler()

void DMA13_DMA29_DriverIRQHandler ( void  )

Definition at line 2012 of file fsl_edma.c.

2013{
2014 if ((EDMA_GetChannelStatusFlags(DMA0, 13U) & kEDMA_InterruptFlag) != 0U)
2015 {
2016 EDMA_HandleIRQ(s_EDMAHandle[13]);
2017 }
2018 if ((EDMA_GetChannelStatusFlags(DMA0, 29U) & kEDMA_InterruptFlag) != 0U)
2019 {
2020 EDMA_HandleIRQ(s_EDMAHandle[29]);
2021 }
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:

◆ DMA13_DriverIRQHandler()

void DMA13_DriverIRQHandler ( void  )

Definition at line 2480 of file fsl_edma.c.

2481{
2482 EDMA_HandleIRQ(s_EDMAHandle[13]);
2483/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2484 exception return operation might vector to incorrect interrupt */
2485#if defined __CORTEX_M && (__CORTEX_M == 4U)
2486 __DSB();
2487#endif
2488}
Here is the call graph for this function:

◆ DMA14_DMA30_DriverIRQHandler()

void DMA14_DMA30_DriverIRQHandler ( void  )

Definition at line 2029 of file fsl_edma.c.

2030{
2031 if ((EDMA_GetChannelStatusFlags(DMA0, 14U) & kEDMA_InterruptFlag) != 0U)
2032 {
2033 EDMA_HandleIRQ(s_EDMAHandle[14]);
2034 }
2035 if ((EDMA_GetChannelStatusFlags(DMA0, 30U) & kEDMA_InterruptFlag) != 0U)
2036 {
2037 EDMA_HandleIRQ(s_EDMAHandle[30]);
2038 }
2039/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2040 exception return operation might vector to incorrect interrupt */
2041#if defined __CORTEX_M && (__CORTEX_M == 4U)
2042 __DSB();
2043#endif
2044}
Here is the call graph for this function:

◆ DMA14_DriverIRQHandler()

void DMA14_DriverIRQHandler ( void  )

Definition at line 2490 of file fsl_edma.c.

2491{
2492 EDMA_HandleIRQ(s_EDMAHandle[14]);
2493/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2494 exception return operation might vector to incorrect interrupt */
2495#if defined __CORTEX_M && (__CORTEX_M == 4U)
2496 __DSB();
2497#endif
2498}
Here is the call graph for this function:

◆ DMA15_DMA31_DriverIRQHandler()

void DMA15_DMA31_DriverIRQHandler ( void  )

Definition at line 2046 of file fsl_edma.c.

2047{
2048 if ((EDMA_GetChannelStatusFlags(DMA0, 15U) & kEDMA_InterruptFlag) != 0U)
2049 {
2050 EDMA_HandleIRQ(s_EDMAHandle[15]);
2051 }
2052 if ((EDMA_GetChannelStatusFlags(DMA0, 31U) & kEDMA_InterruptFlag) != 0U)
2053 {
2054 EDMA_HandleIRQ(s_EDMAHandle[31]);
2055 }
2056/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2057 exception return operation might vector to incorrect interrupt */
2058#if defined __CORTEX_M && (__CORTEX_M == 4U)
2059 __DSB();
2060#endif
2061}
Here is the call graph for this function:

◆ DMA15_DriverIRQHandler()

void DMA15_DriverIRQHandler ( void  )

Definition at line 2500 of file fsl_edma.c.

2501{
2502 EDMA_HandleIRQ(s_EDMAHandle[15]);
2503/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2504 exception return operation might vector to incorrect interrupt */
2505#if defined __CORTEX_M && (__CORTEX_M == 4U)
2506 __DSB();
2507#endif
2508}
Here is the call graph for this function:

◆ DMA16_DriverIRQHandler()

void DMA16_DriverIRQHandler ( void  )

Definition at line 2514 of file fsl_edma.c.

2515{
2516 EDMA_HandleIRQ(s_EDMAHandle[16]);
2517/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2518 exception return operation might vector to incorrect interrupt */
2519#if defined __CORTEX_M && (__CORTEX_M == 4U)
2520 __DSB();
2521#endif
2522}
Here is the call graph for this function:

◆ DMA17_DriverIRQHandler()

void DMA17_DriverIRQHandler ( void  )

Definition at line 2524 of file fsl_edma.c.

2525{
2526 EDMA_HandleIRQ(s_EDMAHandle[17]);
2527/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2528 exception return operation might vector to incorrect interrupt */
2529#if defined __CORTEX_M && (__CORTEX_M == 4U)
2530 __DSB();
2531#endif
2532}
Here is the call graph for this function:

◆ DMA18_DriverIRQHandler()

void DMA18_DriverIRQHandler ( void  )

Definition at line 2534 of file fsl_edma.c.

2535{
2536 EDMA_HandleIRQ(s_EDMAHandle[18]);
2537/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2538 exception return operation might vector to incorrect interrupt */
2539#if defined __CORTEX_M && (__CORTEX_M == 4U)
2540 __DSB();
2541#endif
2542}
Here is the call graph for this function:

◆ DMA19_DriverIRQHandler()

void DMA19_DriverIRQHandler ( void  )

Definition at line 2544 of file fsl_edma.c.

2545{
2546 EDMA_HandleIRQ(s_EDMAHandle[19]);
2547/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2548 exception return operation might vector to incorrect interrupt */
2549#if defined __CORTEX_M && (__CORTEX_M == 4U)
2550 __DSB();
2551#endif
2552}
Here is the call graph for this function:

◆ DMA1_04_DriverIRQHandler()

void DMA1_04_DriverIRQHandler ( void  )

Definition at line 1370 of file fsl_edma.c.

1371{
1372 if ((EDMA_GetChannelStatusFlags(DMA1, 0U) & kEDMA_InterruptFlag) != 0U)
1373 {
1374 EDMA_HandleIRQ(s_EDMAHandle[8]);
1375 }
1376 if ((EDMA_GetChannelStatusFlags(DMA1, 4U) & kEDMA_InterruptFlag) != 0U)
1377 {
1378 EDMA_HandleIRQ(s_EDMAHandle[12]);
1379 }
1380/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1381 exception return operation might vector to incorrect interrupt */
1382#if defined __CORTEX_M && (__CORTEX_M == 4U)
1383 __DSB();
1384#endif
1385}
Here is the call graph for this function:

◆ DMA1_08_DriverIRQHandler()

void DMA1_08_DriverIRQHandler ( void  )

Definition at line 1650 of file fsl_edma.c.

1651{
1652 if ((EDMA_GetChannelStatusFlags(DMA1, 0U) & kEDMA_InterruptFlag) != 0U)
1653 {
1654 EDMA_HandleIRQ(s_EDMAHandle[16]);
1655 }
1656 if ((EDMA_GetChannelStatusFlags(DMA1, 8U) & kEDMA_InterruptFlag) != 0U)
1657 {
1658 EDMA_HandleIRQ(s_EDMAHandle[24]);
1659 }
1660/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1661 exception return operation might vector to incorrect interrupt */
1662#if defined __CORTEX_M && (__CORTEX_M == 4U)
1663 __DSB();
1664#endif
1665}
Here is the call graph for this function:

◆ DMA1_15_DriverIRQHandler()

void DMA1_15_DriverIRQHandler ( void  )

Definition at line 1387 of file fsl_edma.c.

1388{
1389 if ((EDMA_GetChannelStatusFlags(DMA1, 1U) & kEDMA_InterruptFlag) != 0U)
1390 {
1391 EDMA_HandleIRQ(s_EDMAHandle[9]);
1392 }
1393 if ((EDMA_GetChannelStatusFlags(DMA1, 5U) & kEDMA_InterruptFlag) != 0U)
1394 {
1395 EDMA_HandleIRQ(s_EDMAHandle[13]);
1396 }
1397/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1398 exception return operation might vector to incorrect interrupt */
1399#if defined __CORTEX_M && (__CORTEX_M == 4U)
1400 __DSB();
1401#endif
1402}
Here is the call graph for this function:

◆ DMA1_19_DriverIRQHandler()

void DMA1_19_DriverIRQHandler ( void  )

Definition at line 1667 of file fsl_edma.c.

1668{
1669 if ((EDMA_GetChannelStatusFlags(DMA1, 1U) & kEDMA_InterruptFlag) != 0U)
1670 {
1671 EDMA_HandleIRQ(s_EDMAHandle[17]);
1672 }
1673 if ((EDMA_GetChannelStatusFlags(DMA1, 9U) & kEDMA_InterruptFlag) != 0U)
1674 {
1675 EDMA_HandleIRQ(s_EDMAHandle[25]);
1676 }
1677/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1678 exception return operation might vector to incorrect interrupt */
1679#if defined __CORTEX_M && (__CORTEX_M == 4U)
1680 __DSB();
1681#endif
1682}
Here is the call graph for this function:

◆ DMA1_210_DriverIRQHandler()

void DMA1_210_DriverIRQHandler ( void  )

Definition at line 1684 of file fsl_edma.c.

1685{
1686 if ((EDMA_GetChannelStatusFlags(DMA1, 2U) & kEDMA_InterruptFlag) != 0U)
1687 {
1688 EDMA_HandleIRQ(s_EDMAHandle[18]);
1689 }
1690 if ((EDMA_GetChannelStatusFlags(DMA1, 10U) & kEDMA_InterruptFlag) != 0U)
1691 {
1692 EDMA_HandleIRQ(s_EDMAHandle[26]);
1693 }
1694/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1695 exception return operation might vector to incorrect interrupt */
1696#if defined __CORTEX_M && (__CORTEX_M == 4U)
1697 __DSB();
1698#endif
1699}
Here is the call graph for this function:

◆ DMA1_26_DriverIRQHandler()

void DMA1_26_DriverIRQHandler ( void  )

Definition at line 1404 of file fsl_edma.c.

1405{
1406 if ((EDMA_GetChannelStatusFlags(DMA1, 2U) & kEDMA_InterruptFlag) != 0U)
1407 {
1408 EDMA_HandleIRQ(s_EDMAHandle[10]);
1409 }
1410 if ((EDMA_GetChannelStatusFlags(DMA1, 6U) & kEDMA_InterruptFlag) != 0U)
1411 {
1412 EDMA_HandleIRQ(s_EDMAHandle[14]);
1413 }
1414/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1415 exception return operation might vector to incorrect interrupt */
1416#if defined __CORTEX_M && (__CORTEX_M == 4U)
1417 __DSB();
1418#endif
1419}
Here is the call graph for this function:

◆ DMA1_311_DriverIRQHandler()

void DMA1_311_DriverIRQHandler ( void  )

Definition at line 1701 of file fsl_edma.c.

1702{
1703 if ((EDMA_GetChannelStatusFlags(DMA1, 3U) & kEDMA_InterruptFlag) != 0U)
1704 {
1705 EDMA_HandleIRQ(s_EDMAHandle[19]);
1706 }
1707 if ((EDMA_GetChannelStatusFlags(DMA1, 11U) & kEDMA_InterruptFlag) != 0U)
1708 {
1709 EDMA_HandleIRQ(s_EDMAHandle[27]);
1710 }
1711/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1712 exception return operation might vector to incorrect interrupt */
1713#if defined __CORTEX_M && (__CORTEX_M == 4U)
1714 __DSB();
1715#endif
1716}
Here is the call graph for this function:

◆ DMA1_37_DriverIRQHandler()

void DMA1_37_DriverIRQHandler ( void  )

Definition at line 1421 of file fsl_edma.c.

1422{
1423 if ((EDMA_GetChannelStatusFlags(DMA1, 3U) & kEDMA_InterruptFlag) != 0U)
1424 {
1425 EDMA_HandleIRQ(s_EDMAHandle[11]);
1426 }
1427 if ((EDMA_GetChannelStatusFlags(DMA1, 7U) & kEDMA_InterruptFlag) != 0U)
1428 {
1429 EDMA_HandleIRQ(s_EDMAHandle[15]);
1430 }
1431/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1432 exception return operation might vector to incorrect interrupt */
1433#if defined __CORTEX_M && (__CORTEX_M == 4U)
1434 __DSB();
1435#endif
1436}
Here is the call graph for this function:

◆ DMA1_412_DriverIRQHandler()

void DMA1_412_DriverIRQHandler ( void  )

Definition at line 1718 of file fsl_edma.c.

1719{
1720 if ((EDMA_GetChannelStatusFlags(DMA1, 4U) & kEDMA_InterruptFlag) != 0U)
1721 {
1722 EDMA_HandleIRQ(s_EDMAHandle[20]);
1723 }
1724 if ((EDMA_GetChannelStatusFlags(DMA1, 12U) & kEDMA_InterruptFlag) != 0U)
1725 {
1726 EDMA_HandleIRQ(s_EDMAHandle[28]);
1727 }
1728/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1729 exception return operation might vector to incorrect interrupt */
1730#if defined __CORTEX_M && (__CORTEX_M == 4U)
1731 __DSB();
1732#endif
1733}
Here is the call graph for this function:

◆ DMA1_513_DriverIRQHandler()

void DMA1_513_DriverIRQHandler ( void  )

Definition at line 1735 of file fsl_edma.c.

1736{
1737 if ((EDMA_GetChannelStatusFlags(DMA1, 5U) & kEDMA_InterruptFlag) != 0U)
1738 {
1739 EDMA_HandleIRQ(s_EDMAHandle[21]);
1740 }
1741 if ((EDMA_GetChannelStatusFlags(DMA1, 13U) & kEDMA_InterruptFlag) != 0U)
1742 {
1743 EDMA_HandleIRQ(s_EDMAHandle[29]);
1744 }
1745/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1746 exception return operation might vector to incorrect interrupt */
1747#if defined __CORTEX_M && (__CORTEX_M == 4U)
1748 __DSB();
1749#endif
1750}
Here is the call graph for this function:

◆ DMA1_614_DriverIRQHandler()

void DMA1_614_DriverIRQHandler ( void  )

Definition at line 1752 of file fsl_edma.c.

1753{
1754 if ((EDMA_GetChannelStatusFlags(DMA1, 6U) & kEDMA_InterruptFlag) != 0U)
1755 {
1756 EDMA_HandleIRQ(s_EDMAHandle[22]);
1757 }
1758 if ((EDMA_GetChannelStatusFlags(DMA1, 14U) & kEDMA_InterruptFlag) != 0U)
1759 {
1760 EDMA_HandleIRQ(s_EDMAHandle[30]);
1761 }
1762/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1763 exception return operation might vector to incorrect interrupt */
1764#if defined __CORTEX_M && (__CORTEX_M == 4U)
1765 __DSB();
1766#endif
1767}
Here is the call graph for this function:

◆ DMA1_715_DriverIRQHandler()

void DMA1_715_DriverIRQHandler ( void  )

Definition at line 1769 of file fsl_edma.c.

1770{
1771 if ((EDMA_GetChannelStatusFlags(DMA1, 7U) & kEDMA_InterruptFlag) != 0U)
1772 {
1773 EDMA_HandleIRQ(s_EDMAHandle[23]);
1774 }
1775 if ((EDMA_GetChannelStatusFlags(DMA1, 15U) & kEDMA_InterruptFlag) != 0U)
1776 {
1777 EDMA_HandleIRQ(s_EDMAHandle[31]);
1778 }
1779/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1780 exception return operation might vector to incorrect interrupt */
1781#if defined __CORTEX_M && (__CORTEX_M == 4U)
1782 __DSB();
1783#endif
1784}
Here is the call graph for this function:

◆ DMA1_DMA17_DriverIRQHandler()

void DMA1_DMA17_DriverIRQHandler ( void  )

Definition at line 1808 of file fsl_edma.c.

1809{
1810 if ((EDMA_GetChannelStatusFlags(DMA0, 1U) & kEDMA_InterruptFlag) != 0U)
1811 {
1812 EDMA_HandleIRQ(s_EDMAHandle[1]);
1813 }
1814 if ((EDMA_GetChannelStatusFlags(DMA0, 17U) & kEDMA_InterruptFlag) != 0U)
1815 {
1816 EDMA_HandleIRQ(s_EDMAHandle[17]);
1817 }
1818/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1819 exception return operation might vector to incorrect interrupt */
1820#if defined __CORTEX_M && (__CORTEX_M == 4U)
1821 __DSB();
1822#endif
1823}
Here is the call graph for this function:

◆ DMA1_DriverIRQHandler()

void DMA1_DriverIRQHandler ( void  )

Definition at line 2353 of file fsl_edma.c.

2354{
2355 EDMA_HandleIRQ(s_EDMAHandle[1]);
2356/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2357 exception return operation might vector to incorrect interrupt */
2358#if defined __CORTEX_M && (__CORTEX_M == 4U)
2359 __DSB();
2360#endif
2361}
Here is the call graph for this function:

◆ DMA20_DriverIRQHandler()

void DMA20_DriverIRQHandler ( void  )

Definition at line 2554 of file fsl_edma.c.

2555{
2556 EDMA_HandleIRQ(s_EDMAHandle[20]);
2557/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2558 exception return operation might vector to incorrect interrupt */
2559#if defined __CORTEX_M && (__CORTEX_M == 4U)
2560 __DSB();
2561#endif
2562}
Here is the call graph for this function:

◆ DMA21_DriverIRQHandler()

void DMA21_DriverIRQHandler ( void  )

Definition at line 2564 of file fsl_edma.c.

2565{
2566 EDMA_HandleIRQ(s_EDMAHandle[21]);
2567/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2568 exception return operation might vector to incorrect interrupt */
2569#if defined __CORTEX_M && (__CORTEX_M == 4U)
2570 __DSB();
2571#endif
2572}
Here is the call graph for this function:

◆ DMA22_DriverIRQHandler()

void DMA22_DriverIRQHandler ( void  )

Definition at line 2574 of file fsl_edma.c.

2575{
2576 EDMA_HandleIRQ(s_EDMAHandle[22]);
2577/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2578 exception return operation might vector to incorrect interrupt */
2579#if defined __CORTEX_M && (__CORTEX_M == 4U)
2580 __DSB();
2581#endif
2582}
Here is the call graph for this function:

◆ DMA23_DriverIRQHandler()

void DMA23_DriverIRQHandler ( void  )

Definition at line 2584 of file fsl_edma.c.

2585{
2586 EDMA_HandleIRQ(s_EDMAHandle[23]);
2587/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2588 exception return operation might vector to incorrect interrupt */
2589#if defined __CORTEX_M && (__CORTEX_M == 4U)
2590 __DSB();
2591#endif
2592}
Here is the call graph for this function:

◆ DMA24_DriverIRQHandler()

void DMA24_DriverIRQHandler ( void  )

Definition at line 2594 of file fsl_edma.c.

2595{
2596 EDMA_HandleIRQ(s_EDMAHandle[24]);
2597/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2598 exception return operation might vector to incorrect interrupt */
2599#if defined __CORTEX_M && (__CORTEX_M == 4U)
2600 __DSB();
2601#endif
2602}
Here is the call graph for this function:

◆ DMA25_DriverIRQHandler()

void DMA25_DriverIRQHandler ( void  )

Definition at line 2604 of file fsl_edma.c.

2605{
2606 EDMA_HandleIRQ(s_EDMAHandle[25]);
2607/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2608 exception return operation might vector to incorrect interrupt */
2609#if defined __CORTEX_M && (__CORTEX_M == 4U)
2610 __DSB();
2611#endif
2612}
Here is the call graph for this function:

◆ DMA26_DriverIRQHandler()

void DMA26_DriverIRQHandler ( void  )

Definition at line 2614 of file fsl_edma.c.

2615{
2616 EDMA_HandleIRQ(s_EDMAHandle[26]);
2617/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2618 exception return operation might vector to incorrect interrupt */
2619#if defined __CORTEX_M && (__CORTEX_M == 4U)
2620 __DSB();
2621#endif
2622}
Here is the call graph for this function:

◆ DMA27_DriverIRQHandler()

void DMA27_DriverIRQHandler ( void  )

Definition at line 2624 of file fsl_edma.c.

2625{
2626 EDMA_HandleIRQ(s_EDMAHandle[27]);
2627/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2628 exception return operation might vector to incorrect interrupt */
2629#if defined __CORTEX_M && (__CORTEX_M == 4U)
2630 __DSB();
2631#endif
2632}
Here is the call graph for this function:

◆ DMA28_DriverIRQHandler()

void DMA28_DriverIRQHandler ( void  )

Definition at line 2634 of file fsl_edma.c.

2635{
2636 EDMA_HandleIRQ(s_EDMAHandle[28]);
2637/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2638 exception return operation might vector to incorrect interrupt */
2639#if defined __CORTEX_M && (__CORTEX_M == 4U)
2640 __DSB();
2641#endif
2642}
Here is the call graph for this function:

◆ DMA29_DriverIRQHandler()

void DMA29_DriverIRQHandler ( void  )

Definition at line 2644 of file fsl_edma.c.

2645{
2646 EDMA_HandleIRQ(s_EDMAHandle[29]);
2647/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2648 exception return operation might vector to incorrect interrupt */
2649#if defined __CORTEX_M && (__CORTEX_M == 4U)
2650 __DSB();
2651#endif
2652}
Here is the call graph for this function:

◆ DMA2_DMA18_DriverIRQHandler()

void DMA2_DMA18_DriverIRQHandler ( void  )

Definition at line 1825 of file fsl_edma.c.

1826{
1827 if ((EDMA_GetChannelStatusFlags(DMA0, 2U) & kEDMA_InterruptFlag) != 0U)
1828 {
1829 EDMA_HandleIRQ(s_EDMAHandle[2]);
1830 }
1831 if ((EDMA_GetChannelStatusFlags(DMA0, 18U) & kEDMA_InterruptFlag) != 0U)
1832 {
1833 EDMA_HandleIRQ(s_EDMAHandle[18]);
1834 }
1835/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1836 exception return operation might vector to incorrect interrupt */
1837#if defined __CORTEX_M && (__CORTEX_M == 4U)
1838 __DSB();
1839#endif
1840}
Here is the call graph for this function:

◆ DMA2_DriverIRQHandler()

void DMA2_DriverIRQHandler ( void  )

Definition at line 2363 of file fsl_edma.c.

2364{
2365 EDMA_HandleIRQ(s_EDMAHandle[2]);
2366/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2367 exception return operation might vector to incorrect interrupt */
2368#if defined __CORTEX_M && (__CORTEX_M == 4U)
2369 __DSB();
2370#endif
2371}
Here is the call graph for this function:

◆ DMA30_DriverIRQHandler()

void DMA30_DriverIRQHandler ( void  )

Definition at line 2654 of file fsl_edma.c.

2655{
2656 EDMA_HandleIRQ(s_EDMAHandle[30]);
2657/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2658 exception return operation might vector to incorrect interrupt */
2659#if defined __CORTEX_M && (__CORTEX_M == 4U)
2660 __DSB();
2661#endif
2662}
Here is the call graph for this function:

◆ DMA31_DriverIRQHandler()

void DMA31_DriverIRQHandler ( void  )

Definition at line 2664 of file fsl_edma.c.

2665{
2666 EDMA_HandleIRQ(s_EDMAHandle[31]);
2667/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2668 exception return operation might vector to incorrect interrupt */
2669#if defined __CORTEX_M && (__CORTEX_M == 4U)
2670 __DSB();
2671#endif
2672}
Here is the call graph for this function:

◆ DMA3_DMA19_DriverIRQHandler()

void DMA3_DMA19_DriverIRQHandler ( void  )

Definition at line 1842 of file fsl_edma.c.

1843{
1844 if ((EDMA_GetChannelStatusFlags(DMA0, 3U) & kEDMA_InterruptFlag) != 0U)
1845 {
1846 EDMA_HandleIRQ(s_EDMAHandle[3]);
1847 }
1848 if ((EDMA_GetChannelStatusFlags(DMA0, 19U) & kEDMA_InterruptFlag) != 0U)
1849 {
1850 EDMA_HandleIRQ(s_EDMAHandle[19]);
1851 }
1852/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1853 exception return operation might vector to incorrect interrupt */
1854#if defined __CORTEX_M && (__CORTEX_M == 4U)
1855 __DSB();
1856#endif
1857}
Here is the call graph for this function:

◆ DMA3_DriverIRQHandler()

void DMA3_DriverIRQHandler ( void  )

Definition at line 2373 of file fsl_edma.c.

2374{
2375 EDMA_HandleIRQ(s_EDMAHandle[3]);
2376/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2377 exception return operation might vector to incorrect interrupt */
2378#if defined __CORTEX_M && (__CORTEX_M == 4U)
2379 __DSB();
2380#endif
2381}
Here is the call graph for this function:

◆ DMA4_DMA20_DriverIRQHandler()

void DMA4_DMA20_DriverIRQHandler ( void  )

Definition at line 1859 of file fsl_edma.c.

1860{
1861 if ((EDMA_GetChannelStatusFlags(DMA0, 4U) & kEDMA_InterruptFlag) != 0U)
1862 {
1863 EDMA_HandleIRQ(s_EDMAHandle[4]);
1864 }
1865 if ((EDMA_GetChannelStatusFlags(DMA0, 20U) & kEDMA_InterruptFlag) != 0U)
1866 {
1867 EDMA_HandleIRQ(s_EDMAHandle[20]);
1868 }
1869/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1870 exception return operation might vector to incorrect interrupt */
1871#if defined __CORTEX_M && (__CORTEX_M == 4U)
1872 __DSB();
1873#endif
1874}
Here is the call graph for this function:

◆ DMA4_DriverIRQHandler()

void DMA4_DriverIRQHandler ( void  )

Definition at line 2386 of file fsl_edma.c.

2387{
2388 EDMA_HandleIRQ(s_EDMAHandle[4]);
2389/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2390 exception return operation might vector to incorrect interrupt */
2391#if defined __CORTEX_M && (__CORTEX_M == 4U)
2392 __DSB();
2393#endif
2394}
Here is the call graph for this function:

◆ DMA5_DMA21_DriverIRQHandler()

void DMA5_DMA21_DriverIRQHandler ( void  )

Definition at line 1876 of file fsl_edma.c.

1877{
1878 if ((EDMA_GetChannelStatusFlags(DMA0, 5U) & kEDMA_InterruptFlag) != 0U)
1879 {
1880 EDMA_HandleIRQ(s_EDMAHandle[5]);
1881 }
1882 if ((EDMA_GetChannelStatusFlags(DMA0, 21U) & kEDMA_InterruptFlag) != 0U)
1883 {
1884 EDMA_HandleIRQ(s_EDMAHandle[21]);
1885 }
1886/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1887 exception return operation might vector to incorrect interrupt */
1888#if defined __CORTEX_M && (__CORTEX_M == 4U)
1889 __DSB();
1890#endif
1891}
Here is the call graph for this function:

◆ DMA5_DriverIRQHandler()

void DMA5_DriverIRQHandler ( void  )

Definition at line 2396 of file fsl_edma.c.

2397{
2398 EDMA_HandleIRQ(s_EDMAHandle[5]);
2399/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2400 exception return operation might vector to incorrect interrupt */
2401#if defined __CORTEX_M && (__CORTEX_M == 4U)
2402 __DSB();
2403#endif
2404}
Here is the call graph for this function:

◆ DMA6_DMA22_DriverIRQHandler()

void DMA6_DMA22_DriverIRQHandler ( void  )

Definition at line 1893 of file fsl_edma.c.

1894{
1895 if ((EDMA_GetChannelStatusFlags(DMA0, 6U) & kEDMA_InterruptFlag) != 0U)
1896 {
1897 EDMA_HandleIRQ(s_EDMAHandle[6]);
1898 }
1899 if ((EDMA_GetChannelStatusFlags(DMA0, 22U) & kEDMA_InterruptFlag) != 0U)
1900 {
1901 EDMA_HandleIRQ(s_EDMAHandle[22]);
1902 }
1903/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1904 exception return operation might vector to incorrect interrupt */
1905#if defined __CORTEX_M && (__CORTEX_M == 4U)
1906 __DSB();
1907#endif
1908}
Here is the call graph for this function:

◆ DMA6_DriverIRQHandler()

void DMA6_DriverIRQHandler ( void  )

Definition at line 2406 of file fsl_edma.c.

2407{
2408 EDMA_HandleIRQ(s_EDMAHandle[6]);
2409/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2410 exception return operation might vector to incorrect interrupt */
2411#if defined __CORTEX_M && (__CORTEX_M == 4U)
2412 __DSB();
2413#endif
2414}
Here is the call graph for this function:

◆ DMA7_DMA23_DriverIRQHandler()

void DMA7_DMA23_DriverIRQHandler ( void  )

Definition at line 1910 of file fsl_edma.c.

1911{
1912 if ((EDMA_GetChannelStatusFlags(DMA0, 7U) & kEDMA_InterruptFlag) != 0U)
1913 {
1914 EDMA_HandleIRQ(s_EDMAHandle[7]);
1915 }
1916 if ((EDMA_GetChannelStatusFlags(DMA0, 23U) & kEDMA_InterruptFlag) != 0U)
1917 {
1918 EDMA_HandleIRQ(s_EDMAHandle[23]);
1919 }
1920/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1921 exception return operation might vector to incorrect interrupt */
1922#if defined __CORTEX_M && (__CORTEX_M == 4U)
1923 __DSB();
1924#endif
1925}
Here is the call graph for this function:

◆ DMA7_DriverIRQHandler()

void DMA7_DriverIRQHandler ( void  )

Definition at line 2416 of file fsl_edma.c.

2417{
2418 EDMA_HandleIRQ(s_EDMAHandle[7]);
2419/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2420 exception return operation might vector to incorrect interrupt */
2421#if defined __CORTEX_M && (__CORTEX_M == 4U)
2422 __DSB();
2423#endif
2424}
Here is the call graph for this function:

◆ DMA8_DMA24_DriverIRQHandler()

void DMA8_DMA24_DriverIRQHandler ( void  )

Definition at line 1927 of file fsl_edma.c.

1928{
1929 if ((EDMA_GetChannelStatusFlags(DMA0, 8U) & kEDMA_InterruptFlag) != 0U)
1930 {
1931 EDMA_HandleIRQ(s_EDMAHandle[8]);
1932 }
1933 if ((EDMA_GetChannelStatusFlags(DMA0, 24U) & kEDMA_InterruptFlag) != 0U)
1934 {
1935 EDMA_HandleIRQ(s_EDMAHandle[24]);
1936 }
1937/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1938 exception return operation might vector to incorrect interrupt */
1939#if defined __CORTEX_M && (__CORTEX_M == 4U)
1940 __DSB();
1941#endif
1942}
Here is the call graph for this function:

◆ DMA8_DriverIRQHandler()

void DMA8_DriverIRQHandler ( void  )

Definition at line 2430 of file fsl_edma.c.

2431{
2432 EDMA_HandleIRQ(s_EDMAHandle[8]);
2433/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2434 exception return operation might vector to incorrect interrupt */
2435#if defined __CORTEX_M && (__CORTEX_M == 4U)
2436 __DSB();
2437#endif
2438}
Here is the call graph for this function:

◆ DMA9_DMA25_DriverIRQHandler()

void DMA9_DMA25_DriverIRQHandler ( void  )

Definition at line 1944 of file fsl_edma.c.

1945{
1946 if ((EDMA_GetChannelStatusFlags(DMA0, 9U) & kEDMA_InterruptFlag) != 0U)
1947 {
1948 EDMA_HandleIRQ(s_EDMAHandle[9]);
1949 }
1950 if ((EDMA_GetChannelStatusFlags(DMA0, 25U) & kEDMA_InterruptFlag) != 0U)
1951 {
1952 EDMA_HandleIRQ(s_EDMAHandle[25]);
1953 }
1954/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
1955 exception return operation might vector to incorrect interrupt */
1956#if defined __CORTEX_M && (__CORTEX_M == 4U)
1957 __DSB();
1958#endif
1959}
Here is the call graph for this function:

◆ DMA9_DriverIRQHandler()

void DMA9_DriverIRQHandler ( void  )

Definition at line 2440 of file fsl_edma.c.

2441{
2442 EDMA_HandleIRQ(s_EDMAHandle[9]);
2443/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
2444 exception return operation might vector to incorrect interrupt */
2445#if defined __CORTEX_M && (__CORTEX_M == 4U)
2446 __DSB();
2447#endif
2448}
Here is the call graph for this function:

◆ EDMA_GetInstance()

static uint32_t EDMA_GetInstance ( DMA_Type *  base)
static

Get instance number for EDMA.

Parameters
baseEDMA peripheral base address.

Definition at line 56 of file fsl_edma.c.

57{
58 uint32_t instance;
59
60 /* Find the instance index from base address mappings. */
61 for (instance = 0; instance < ARRAY_SIZE(s_edmaBases); instance++)
62 {
63 if (s_edmaBases[instance] == base)
64 {
65 break;
66 }
67 }
68
69 assert(instance < ARRAY_SIZE(s_edmaBases));
70
71 return instance;
72}
instance
static BenchController instance
Definition bench_test.cpp:337
s_edmaBases
static DMA_Type *const s_edmaBases[]
Array to map EDMA instance number to base pointer.
Definition fsl_edma.c:39

Referenced by EDMA_CreateHandle(), EDMA_Deinit(), EDMA_Init(), and Get_StartInstance().

Here is the caller graph for this function:

◆ Get_StartInstance()

static uint8_t Get_StartInstance ( void  )
static

Definition at line 729 of file fsl_edma.c.

730{
731 static uint8_t StartInstanceNum;
732
733#if defined(DMA0)
734 StartInstanceNum = EDMA_GetInstance(DMA0);
735#elif defined(DMA1)
736 StartInstanceNum = EDMA_GetInstance(DMA1);
737#elif defined(DMA2)
738 StartInstanceNum = EDMA_GetInstance(DMA2);
739#elif defined(DMA3)
740 StartInstanceNum = EDMA_GetInstance(DMA3);
741#endif
742
743 return StartInstanceNum;
744}
EDMA_GetInstance
static uint32_t EDMA_GetInstance(DMA_Type *base)
Get instance number for EDMA.
Definition fsl_edma.c:56

Referenced by EDMA_CreateHandle().

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

Variable Documentation

◆ s_edmaBases

DMA_Type* const s_edmaBases[] = DMA_BASE_PTRS
static

Array to map EDMA instance number to base pointer.

Definition at line 39 of file fsl_edma.c.

Referenced by EDMA_GetInstance().

◆ s_edmaClockName

const clock_ip_name_t s_edmaClockName[] = EDMA_CLOCKS
static

Array to map EDMA instance number to clock name.

Definition at line 43 of file fsl_edma.c.

Referenced by EDMA_Deinit(), and EDMA_Init().

◆ s_EDMAHandle

edma_handle_t* s_EDMAHandle[FSL_FEATURE_EDMA_MODULE_CHANNEL *FSL_FEATURE_SOC_EDMA_COUNT]
static

Pointers to transfer handle for each EDMA channel.

Definition at line 50 of file fsl_edma.c.

Referenced by DMA0_04_DriverIRQHandler(), DMA0_08_DriverIRQHandler(), DMA0_0_4_DriverIRQHandler(), DMA0_10_14_DriverIRQHandler(), DMA0_11_15_DriverIRQHandler(), DMA0_15_DriverIRQHandler(), DMA0_16_20_DriverIRQHandler(), DMA0_17_21_DriverIRQHandler(), DMA0_18_22_DriverIRQHandler(), DMA0_19_23_DriverIRQHandler(), DMA0_19_DriverIRQHandler(), DMA0_1_5_DriverIRQHandler(), DMA0_210_DriverIRQHandler(), DMA0_24_28_DriverIRQHandler(), DMA0_25_29_DriverIRQHandler(), DMA0_26_30_DriverIRQHandler(), DMA0_26_DriverIRQHandler(), DMA0_27_31_DriverIRQHandler(), DMA0_2_6_DriverIRQHandler(), DMA0_311_DriverIRQHandler(), DMA0_37_DriverIRQHandler(), DMA0_3_7_DriverIRQHandler(), DMA0_412_DriverIRQHandler(), DMA0_513_DriverIRQHandler(), DMA0_614_DriverIRQHandler(), DMA0_715_DriverIRQHandler(), DMA0_8_12_DriverIRQHandler(), DMA0_9_13_DriverIRQHandler(), DMA0_DMA16_DriverIRQHandler(), DMA0_DriverIRQHandler(), DMA10_DMA26_DriverIRQHandler(), DMA10_DriverIRQHandler(), DMA11_DMA27_DriverIRQHandler(), DMA11_DriverIRQHandler(), DMA12_DMA28_DriverIRQHandler(), DMA12_DriverIRQHandler(), DMA13_DMA29_DriverIRQHandler(), DMA13_DriverIRQHandler(), DMA14_DMA30_DriverIRQHandler(), DMA14_DriverIRQHandler(), DMA15_DMA31_DriverIRQHandler(), DMA15_DriverIRQHandler(), DMA16_DriverIRQHandler(), DMA17_DriverIRQHandler(), DMA18_DriverIRQHandler(), DMA19_DriverIRQHandler(), DMA1_04_DriverIRQHandler(), DMA1_08_DriverIRQHandler(), DMA1_15_DriverIRQHandler(), DMA1_19_DriverIRQHandler(), DMA1_210_DriverIRQHandler(), DMA1_26_DriverIRQHandler(), DMA1_311_DriverIRQHandler(), DMA1_37_DriverIRQHandler(), DMA1_412_DriverIRQHandler(), DMA1_513_DriverIRQHandler(), DMA1_614_DriverIRQHandler(), DMA1_715_DriverIRQHandler(), DMA1_DMA17_DriverIRQHandler(), DMA1_DriverIRQHandler(), DMA20_DriverIRQHandler(), DMA21_DriverIRQHandler(), DMA22_DriverIRQHandler(), DMA23_DriverIRQHandler(), DMA24_DriverIRQHandler(), DMA25_DriverIRQHandler(), DMA26_DriverIRQHandler(), DMA27_DriverIRQHandler(), DMA28_DriverIRQHandler(), DMA29_DriverIRQHandler(), DMA2_DMA18_DriverIRQHandler(), DMA2_DriverIRQHandler(), DMA30_DriverIRQHandler(), DMA31_DriverIRQHandler(), DMA3_DMA19_DriverIRQHandler(), DMA3_DriverIRQHandler(), DMA4_DMA20_DriverIRQHandler(), DMA4_DriverIRQHandler(), DMA5_DMA21_DriverIRQHandler(), DMA5_DriverIRQHandler(), DMA6_DMA22_DriverIRQHandler(), DMA6_DriverIRQHandler(), DMA7_DMA23_DriverIRQHandler(), DMA7_DriverIRQHandler(), DMA8_DMA24_DriverIRQHandler(), DMA8_DriverIRQHandler(), DMA9_DMA25_DriverIRQHandler(), DMA9_DriverIRQHandler(), and EDMA_CreateHandle().

◆ s_edmaIRQNumber

const IRQn_Type s_edmaIRQNumber[][FSL_FEATURE_EDMA_MODULE_CHANNEL] = DMA_CHN_IRQS
static

Array to map EDMA instance number to IRQ number.

Definition at line 47 of file fsl_edma.c.

Referenced by EDMA_CreateHandle().

Go to the source code of this file.

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