1 /******************************************************************************
2  *
3  * Copyright (C) 2022-2023 Maxim Integrated Products, Inc. (now owned by
4  * Analog Devices, Inc.),
5  * Copyright (C) 2023-2024 Analog Devices, Inc.
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  *     http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  ******************************************************************************/
20 
21 #include <stddef.h>
22 #include <stdint.h>
23 #include "mxc_errors.h"
24 #include "mxc_assert.h"
25 #include "mxc_lock.h"
26 #include "mxc_sys.h"
27 #include "dma.h"
28 #include "dma_reva.h"
29 
30 /* ************************************************************************* */
MXC_DMA_Init(void)31 int MXC_DMA_Init(void)
32 {
33 #ifndef MSDK_NO_GPIO_CLK_INIT
34     if (!MXC_SYS_IsClockEnabled(MXC_SYS_PERIPH_CLOCK_DMA)) {
35         MXC_SYS_ClockEnable(MXC_SYS_PERIPH_CLOCK_DMA);
36         MXC_SYS_Reset_Periph(MXC_SYS_RESET_DMA);
37     }
38 #endif
39 
40     return MXC_DMA_RevA_Init((mxc_dma_reva_regs_t *)MXC_DMA);
41 }
42 
43 /* ************************************************************************* */
MXC_DMA_DeInit(void)44 void MXC_DMA_DeInit(void)
45 {
46     return MXC_DMA_RevA_DeInit((mxc_dma_reva_regs_t *)MXC_DMA);
47 }
48 
49 /* ************************************************************************* */
MXC_DMA_AcquireChannel(void)50 int MXC_DMA_AcquireChannel(void)
51 {
52     return MXC_DMA_RevA_AcquireChannel((mxc_dma_reva_regs_t *)MXC_DMA);
53 }
54 
55 /* ************************************************************************* */
MXC_DMA_ReleaseChannel(int ch)56 int MXC_DMA_ReleaseChannel(int ch)
57 {
58     return MXC_DMA_RevA_ReleaseChannel(ch);
59 }
60 
61 /* ************************************************************************* */
MXC_DMA_ConfigChannel(mxc_dma_config_t config,mxc_dma_srcdst_t srcdst)62 int MXC_DMA_ConfigChannel(mxc_dma_config_t config, mxc_dma_srcdst_t srcdst)
63 {
64     return MXC_DMA_RevA_ConfigChannel(config, srcdst);
65 }
66 
67 /* ************************************************************************* */
MXC_DMA_AdvConfigChannel(mxc_dma_adv_config_t advConfig)68 int MXC_DMA_AdvConfigChannel(mxc_dma_adv_config_t advConfig)
69 {
70     return MXC_DMA_RevA_AdvConfigChannel(advConfig);
71 }
72 
73 /* ************************************************************************* */
MXC_DMA_SetSrcDst(mxc_dma_srcdst_t srcdst)74 int MXC_DMA_SetSrcDst(mxc_dma_srcdst_t srcdst)
75 {
76     return MXC_DMA_RevA_SetSrcDst(srcdst);
77 }
78 
79 /* ************************************************************************* */
MXC_DMA_GetSrcDst(mxc_dma_srcdst_t * srcdst)80 int MXC_DMA_GetSrcDst(mxc_dma_srcdst_t *srcdst)
81 {
82     return MXC_DMA_RevA_GetSrcDst(srcdst);
83 }
84 
85 /* ************************************************************************* */
MXC_DMA_SetSrcReload(mxc_dma_srcdst_t srcdstReload)86 int MXC_DMA_SetSrcReload(mxc_dma_srcdst_t srcdstReload)
87 {
88     return MXC_DMA_RevA_SetSrcReload(srcdstReload);
89 }
90 
91 /* ************************************************************************* */
MXC_DMA_GetSrcReload(mxc_dma_srcdst_t * srcdstReload)92 int MXC_DMA_GetSrcReload(mxc_dma_srcdst_t *srcdstReload)
93 {
94     return MXC_DMA_RevA_GetSrcReload(srcdstReload);
95 }
96 
97 /* ************************************************************************* */
MXC_DMA_SetCallback(int ch,void (* callback)(int,int))98 int MXC_DMA_SetCallback(int ch, void (*callback)(int, int))
99 {
100     return MXC_DMA_RevA_SetCallback(ch, callback);
101 }
102 
103 /* ************************************************************************* */
MXC_DMA_SetChannelInterruptEn(int ch,bool chdis,bool ctz)104 int MXC_DMA_SetChannelInterruptEn(int ch, bool chdis, bool ctz)
105 {
106     return MXC_DMA_RevA_SetChannelInterruptEn(ch, chdis, ctz);
107 }
108 
109 /* ************************************************************************* */
MXC_DMA_ChannelEnableInt(int ch,int flags)110 int MXC_DMA_ChannelEnableInt(int ch, int flags)
111 {
112     return MXC_DMA_RevA_ChannelEnableInt(ch, flags);
113 }
114 
115 /* ************************************************************************* */
MXC_DMA_ChannelDisableInt(int ch,int flags)116 int MXC_DMA_ChannelDisableInt(int ch, int flags)
117 {
118     return MXC_DMA_RevA_ChannelDisableInt(ch, flags);
119 }
120 
121 /* ************************************************************************* */
MXC_DMA_ChannelGetFlags(int ch)122 int MXC_DMA_ChannelGetFlags(int ch)
123 {
124     return MXC_DMA_RevA_ChannelGetFlags(ch);
125 }
126 
127 /* ************************************************************************* */
MXC_DMA_ChannelClearFlags(int ch,int flags)128 int MXC_DMA_ChannelClearFlags(int ch, int flags)
129 {
130     return MXC_DMA_RevA_ChannelClearFlags(ch, flags);
131 }
132 
133 /* ************************************************************************* */
MXC_DMA_EnableInt(int ch)134 int MXC_DMA_EnableInt(int ch)
135 {
136     return MXC_DMA_RevA_EnableInt((mxc_dma_reva_regs_t *)MXC_DMA, ch);
137 }
138 
139 /* ************************************************************************* */
MXC_DMA_DisableInt(int ch)140 int MXC_DMA_DisableInt(int ch)
141 {
142     return MXC_DMA_RevA_DisableInt((mxc_dma_reva_regs_t *)MXC_DMA, ch);
143 }
144 
145 /* ************************************************************************* */
MXC_DMA_Start(int ch)146 int MXC_DMA_Start(int ch)
147 {
148     return MXC_DMA_RevA_Start(ch);
149 }
150 
151 /* ************************************************************************* */
MXC_DMA_Stop(int ch)152 int MXC_DMA_Stop(int ch)
153 {
154     return MXC_DMA_RevA_Stop(ch);
155 }
156 
157 /* ************************************************************************* */
MXC_DMA_GetCHRegs(int ch)158 mxc_dma_ch_regs_t *MXC_DMA_GetCHRegs(int ch)
159 {
160     return MXC_DMA_RevA_GetCHRegs(ch);
161 }
162 
163 /* ************************************************************************* */
MXC_DMA_Handler(void)164 void MXC_DMA_Handler(void)
165 {
166     MXC_DMA_RevA_Handler((mxc_dma_reva_regs_t *)MXC_DMA);
167 }
168 
169 /* ************************************************************************* */
MXC_DMA_MemCpy(void * dest,void * src,int len,mxc_dma_complete_cb_t callback)170 int MXC_DMA_MemCpy(void *dest, void *src, int len, mxc_dma_complete_cb_t callback)
171 {
172     return MXC_DMA_RevA_MemCpy((mxc_dma_reva_regs_t *)MXC_DMA, dest, src, len, callback);
173 }
174 
175 /* ************************************************************************* */
MXC_DMA_DoTransfer(mxc_dma_config_t config,mxc_dma_srcdst_t firstSrcDst,mxc_dma_trans_chain_t callback)176 int MXC_DMA_DoTransfer(mxc_dma_config_t config, mxc_dma_srcdst_t firstSrcDst,
177                        mxc_dma_trans_chain_t callback)
178 {
179     return MXC_DMA_RevA_DoTransfer((mxc_dma_reva_regs_t *)MXC_DMA, config, firstSrcDst, callback);
180 }
181