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
