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 /* **** Includes **** */
22 #include <stddef.h>
23 #include <stdio.h>
24 #include <string.h>
25 #include "mxc_sys.h"
26 #include "mxc_assert.h"
27 #include "spixr.h"
28 #include "spixr_reva.h"
29 #include "tpu.h"
30 #include "mxc_errors.h"
31 
32 /* **** Definitions **** */
33 
34 /* **** Globals **** */
35 
36 /* **** Local Function Prototypes **** */
37 
38 /* ************************************************************************* */
MXC_SPIXR_ReadRXFIFO(uint8_t * buf,int len)39 int MXC_SPIXR_ReadRXFIFO(uint8_t *buf, int len)
40 {
41     return MXC_SPIXR_RevA_ReadRXFIFO((mxc_spixr_reva_regs_t *)MXC_SPIXR, buf, len);
42 }
43 
44 /* ************************************************************************* */
MXC_SPIXR_WriteTXFIFO(uint8_t * buf,int len)45 int MXC_SPIXR_WriteTXFIFO(uint8_t *buf, int len)
46 {
47     return MXC_SPIXR_RevA_WriteTXFIFO((mxc_spixr_reva_regs_t *)MXC_SPIXR, buf, len);
48 }
49 
50 /* ************************************************************************* */
MXC_SPIXR_SetSS(void)51 void MXC_SPIXR_SetSS(void)
52 {
53     MXC_SPIXR_RevA_SetSS((mxc_spixr_reva_regs_t *)MXC_SPIXR, 0);
54 }
55 
56 /* ************************************************************************* */
MXC_SPIXR_GetSS(void)57 int MXC_SPIXR_GetSS(void)
58 {
59     return MXC_SPIXR_RevA_GetSS((mxc_spixr_reva_regs_t *)MXC_SPIXR);
60 }
61 
62 /* ************************************************************************* */
MXC_SPIXR_SetSSCtrl(int stayActive)63 void MXC_SPIXR_SetSSCtrl(int stayActive)
64 {
65     if (stayActive) {
66         MXC_SPIXR_RevA_SetSSCtrl((mxc_spixr_reva_regs_t *)MXC_SPIXR, 1);
67     } else {
68         MXC_SPIXR_RevA_SetSSCtrl((mxc_spixr_reva_regs_t *)MXC_SPIXR, 0);
69     }
70 }
71 
72 /* ************************************************************************* */
MXC_SPIXR_GetSSCtrl(void)73 int MXC_SPIXR_GetSSCtrl(void)
74 {
75     return MXC_SPIXR_RevA_GetSSCtrl((mxc_spixr_reva_regs_t *)MXC_SPIXR);
76 }
77 
78 /* ************************************************************************* */
MXC_SPIXR_Enable(void)79 void MXC_SPIXR_Enable(void)
80 {
81     MXC_SPIXR_RevA_Enable((mxc_spixr_reva_regs_t *)MXC_SPIXR);
82 }
83 
84 /* ************************************************************************* */
MXC_SPIXR_Disable(void)85 void MXC_SPIXR_Disable(void)
86 {
87     MXC_SPIXR_RevA_Disable((mxc_spixr_reva_regs_t *)MXC_SPIXR);
88 }
89 
90 /* ************************************************************************* */
MXC_SPIXR_IsEnabled(void)91 int MXC_SPIXR_IsEnabled(void)
92 {
93     return MXC_SPIXR_RevA_IsEnabled((mxc_spixr_reva_regs_t *)MXC_SPIXR);
94 }
95 
96 /* ************************************************************************* */
MXC_SPIXR_TXFIFOEnable(void)97 void MXC_SPIXR_TXFIFOEnable(void)
98 {
99     MXC_SPIXR_RevA_TXFIFOEnable((mxc_spixr_reva_regs_t *)MXC_SPIXR);
100 }
101 
102 /* ************************************************************************* */
MXC_SPIXR_TXFIFODisable(void)103 void MXC_SPIXR_TXFIFODisable(void)
104 {
105     MXC_SPIXR_RevA_TXFIFODisable((mxc_spixr_reva_regs_t *)MXC_SPIXR);
106 }
107 
108 /* ************************************************************************* */
MXC_SPIXR_TXFIFOIsEnabled(void)109 int MXC_SPIXR_TXFIFOIsEnabled(void)
110 {
111     return MXC_SPIXR_RevA_TXFIFOIsEnabled((mxc_spixr_reva_regs_t *)MXC_SPIXR);
112 }
113 
114 /* ************************************************************************* */
MXC_SPIXR_DMATXFIFOEnable(void)115 void MXC_SPIXR_DMATXFIFOEnable(void)
116 {
117     MXC_SPIXR_RevA_DmaTXFIFOEnable((mxc_spixr_reva_regs_t *)MXC_SPIXR);
118 }
119 
120 /* ************************************************************************* */
MXC_SPIXR_DMATXFIFODisable(void)121 void MXC_SPIXR_DMATXFIFODisable(void)
122 {
123     MXC_SPIXR_RevA_DmaTXFIFODisable((mxc_spixr_reva_regs_t *)MXC_SPIXR);
124 }
125 
126 /* ************************************************************************* */
MXC_SPIXR_DMATXFIFOIsEnabled(void)127 int MXC_SPIXR_DMATXFIFOIsEnabled(void)
128 {
129     return MXC_SPIXR_RevA_DmaTXFIFOIsEnabled((mxc_spixr_reva_regs_t *)MXC_SPIXR);
130 }
131 
132 /* ************************************************************************* */
MXC_SPIXR_RXFIFOEnable(void)133 void MXC_SPIXR_RXFIFOEnable(void)
134 {
135     MXC_SPIXR_RevA_RXFIFOEnable((mxc_spixr_reva_regs_t *)MXC_SPIXR);
136 }
137 
138 /* ************************************************************************* */
MXC_SPIXR_RXFIFODisable(void)139 void MXC_SPIXR_RXFIFODisable(void)
140 {
141     MXC_SPIXR_RevA_RXFIFODisable((mxc_spixr_reva_regs_t *)MXC_SPIXR);
142 }
143 
144 /* ************************************************************************* */
MXC_SPIXR_RXFIFOIsEnabled(void)145 int MXC_SPIXR_RXFIFOIsEnabled(void)
146 {
147     return MXC_SPIXR_RevA_RXFIFOIsEnabled((mxc_spixr_reva_regs_t *)MXC_SPIXR);
148 }
149 
150 /* ************************************************************************* */
MXC_SPIXR_DMARXFIFOEnable(void)151 void MXC_SPIXR_DMARXFIFOEnable(void)
152 {
153     MXC_SPIXR_RevA_DmaRXFIFOEnable((mxc_spixr_reva_regs_t *)MXC_SPIXR);
154 }
155 
156 /* ************************************************************************* */
MXC_SPIXR_DMARXFIFODisable(void)157 void MXC_SPIXR_DMARXFIFODisable(void)
158 {
159     MXC_SPIXR_RevA_DmaRXFIFODisable((mxc_spixr_reva_regs_t *)MXC_SPIXR);
160 }
161 
162 /* ************************************************************************* */
MXC_SPIXR_DMARXFIFOIsEnabled(void)163 int MXC_SPIXR_DMARXFIFOIsEnabled(void)
164 {
165     return MXC_SPIXR_RevA_DmaRXFIFOIsEnabled((mxc_spixr_reva_regs_t *)MXC_SPIXR);
166 }
167 
168 /* ************************************************************************* */
MXC_SPIXR_ThreeWireModeEnable(void)169 void MXC_SPIXR_ThreeWireModeEnable(void)
170 {
171     MXC_SPIXR_RevA_ThreeWireModeEnable((mxc_spixr_reva_regs_t *)MXC_SPIXR);
172 }
173 
174 /* ************************************************************************* */
MXC_SPIXR_ThreeWireModeDisable(void)175 void MXC_SPIXR_ThreeWireModeDisable(void)
176 {
177     MXC_SPIXR_RevA_ThreeWireModeDisable((mxc_spixr_reva_regs_t *)MXC_SPIXR);
178 }
179 
180 /* ************************************************************************* */
MXC_SPIXR_ThreeWireModeIsEnabled(void)181 int MXC_SPIXR_ThreeWireModeIsEnabled(void)
182 {
183     return MXC_SPIXR_RevA_ThreeWireModeIsEnabled((mxc_spixr_reva_regs_t *)MXC_SPIXR);
184 }
185 
186 /* ************************************************************************* */
MXC_SPIXR_GetTXFIFOCount(void)187 int MXC_SPIXR_GetTXFIFOCount(void)
188 {
189     return MXC_SPIXR_RevA_GetTXFIFOCount((mxc_spixr_reva_regs_t *)MXC_SPIXR);
190 }
191 
192 /* ************************************************************************* */
MXC_SPIXR_GetRXFIFOCount(void)193 int MXC_SPIXR_GetRXFIFOCount(void)
194 {
195     return MXC_SPIXR_RevA_GetRXFIFOCount((mxc_spixr_reva_regs_t *)MXC_SPIXR);
196 }
197 
198 /* ************************************************************************* */
MXC_SPIXR_TXFIFOClear(void)199 void MXC_SPIXR_TXFIFOClear(void)
200 {
201     MXC_SPIXR_RevA_TXFIFOClear((mxc_spixr_reva_regs_t *)MXC_SPIXR);
202 }
203 
204 /* ************************************************************************* */
MXC_SPIXR_RXFIFOClear(void)205 void MXC_SPIXR_RXFIFOClear(void)
206 {
207     MXC_SPIXR_RevA_RXFIFOClear((mxc_spixr_reva_regs_t *)MXC_SPIXR);
208 }
209 
210 /* ************************************************************************* */
MXC_SPIXR_SetWidth(mxc_spixr_width_t width)211 int MXC_SPIXR_SetWidth(mxc_spixr_width_t width)
212 {
213     return MXC_SPIXR_RevA_SetWidth((mxc_spixr_reva_regs_t *)MXC_SPIXR, width);
214 }
215 
216 /* ************************************************************************* */
MXC_SPIXR_SetSPIMode(mxc_spixr_mode_t mode)217 int MXC_SPIXR_SetSPIMode(mxc_spixr_mode_t mode)
218 {
219     return MXC_SPIXR_RevA_SetSPIMode((mxc_spixr_reva_regs_t *)MXC_SPIXR, mode);
220 }
221 
222 /* ************************************************************************* */
MXC_SPIXR_SetSSPolarity(int activeLow)223 int MXC_SPIXR_SetSSPolarity(int activeLow)
224 {
225     return MXC_SPIXR_RevA_SetSSPolarity((mxc_spixr_reva_regs_t *)MXC_SPIXR, !activeLow);
226 }
227 
228 /* ************************************************************************* */
MXC_SPIXR_SetSSTiming(unsigned int ssIActDelay,unsigned int postActive,unsigned int preActive)229 void MXC_SPIXR_SetSSTiming(unsigned int ssIActDelay, unsigned int postActive,
230                            unsigned int preActive)
231 {
232     MXC_SPIXR_RevA_SetSSTiming((mxc_spixr_reva_regs_t *)MXC_SPIXR, ssIActDelay, postActive,
233                                preActive);
234 }
235 
236 /* ************************************************************************* */
MXC_SPIXR_SetFrequency(int hz)237 int MXC_SPIXR_SetFrequency(int hz)
238 {
239     return MXC_SPIXR_RevA_SetFrequency((mxc_spixr_reva_regs_t *)MXC_SPIXR, hz);
240 }
241 
242 /* ************************************************************************* */
MXC_SPIXR_GetFrequency(void)243 int MXC_SPIXR_GetFrequency(void)
244 {
245     return MXC_SPIXR_RevA_GetFrequency((mxc_spixr_reva_regs_t *)MXC_SPIXR);
246 }
247 
248 /* ************************************************************************* */
MXC_SPIXR_GetIntFlags(void)249 int MXC_SPIXR_GetIntFlags(void)
250 {
251     return MXC_SPIXR_RevA_GetIntFlags((mxc_spixr_reva_regs_t *)MXC_SPIXR);
252 }
253 
254 /* ************************************************************************* */
MXC_SPIXR_EnableInt(int flags)255 void MXC_SPIXR_EnableInt(int flags)
256 {
257     MXC_SPIXR_RevA_EnableInt((mxc_spixr_reva_regs_t *)MXC_SPIXR, flags);
258 }
259 
260 /* ************************************************************************* */
MXC_SPIXR_DisableInt(int flags)261 void MXC_SPIXR_DisableInt(int flags)
262 {
263     MXC_SPIXR_RevA_DisableInt((mxc_spixr_reva_regs_t *)MXC_SPIXR, flags);
264 }
265 
266 /* ************************************************************************* */
MXC_SPIXR_GetWakeUpFlags(void)267 int MXC_SPIXR_GetWakeUpFlags(void)
268 {
269     return MXC_SPIXR_RevA_GetWakeUpFlags((mxc_spixr_reva_regs_t *)MXC_SPIXR);
270 }
271 
272 /* ************************************************************************* */
MXC_SPIXR_EnableWakeUp(int flags)273 void MXC_SPIXR_EnableWakeUp(int flags)
274 {
275     MXC_SPIXR_RevA_EnableWakeUp((mxc_spixr_reva_regs_t *)MXC_SPIXR, flags);
276 }
277 
278 /* ************************************************************************* */
MXC_SPIXR_DisableWakeUp(int flags)279 void MXC_SPIXR_DisableWakeUp(int flags)
280 {
281     MXC_SPIXR_RevA_DisableWakeUp((mxc_spixr_reva_regs_t *)MXC_SPIXR, flags);
282 }
283 
284 /* ************************************************************************* */
MXC_SPIXR_ExMemEnable(void)285 void MXC_SPIXR_ExMemEnable(void)
286 {
287     MXC_SPIXR_RevA_ExMemEnable((mxc_spixr_reva_regs_t *)MXC_SPIXR);
288 }
289 
290 /* ************************************************************************* */
MXC_SPIXR_ExMemDisable(void)291 void MXC_SPIXR_ExMemDisable(void)
292 {
293     MXC_SPIXR_RevA_ExMemDisable((mxc_spixr_reva_regs_t *)MXC_SPIXR);
294 }
295 
296 /* ************************************************************************* */
MXC_SPIXR_ExMemUseDummy(int delay255)297 void MXC_SPIXR_ExMemUseDummy(int delay255)
298 {
299     MXC_SPIXR_RevA_ExMemUseDummy((mxc_spixr_reva_regs_t *)MXC_SPIXR, delay255);
300 }
301 
302 /* ************************************************************************* */
MXC_SPIXR_ExMemSetWriteCommand(uint8_t command)303 void MXC_SPIXR_ExMemSetWriteCommand(uint8_t command)
304 {
305     MXC_SPIXR_RevA_ExMemSetWriteCommand((mxc_spixr_reva_regs_t *)MXC_SPIXR, command);
306 }
307 
308 /* ************************************************************************* */
MXC_SPIXR_ExMemGetWriteCommand(void)309 uint8_t MXC_SPIXR_ExMemGetWriteCommand(void)
310 {
311     return MXC_SPIXR_RevA_ExMemGetWriteCommand((mxc_spixr_reva_regs_t *)MXC_SPIXR);
312 }
313 
314 /* ************************************************************************* */
MXC_SPIXR_ExMemSetReadCommand(uint8_t command)315 void MXC_SPIXR_ExMemSetReadCommand(uint8_t command)
316 {
317     MXC_SPIXR_RevA_ExMemSetReadCommand((mxc_spixr_reva_regs_t *)MXC_SPIXR, command);
318 }
319 
320 /* ************************************************************************* */
MXC_SPIXR_ExMemGetReadCommand(void)321 uint8_t MXC_SPIXR_ExMemGetReadCommand(void)
322 {
323     return MXC_SPIXR_RevA_ExMemGetReadCommand((mxc_spixr_reva_regs_t *)MXC_SPIXR);
324 }
325 
326 /* ************************************************************************* */
MXC_SPIXR_Busy(void)327 int MXC_SPIXR_Busy(void)
328 {
329     return MXC_SPIXR_RevA_Busy((mxc_spixr_reva_regs_t *)MXC_SPIXR);
330 }
331 
332 /* ************************************************************************* */
MXC_SPIXR_Init(mxc_spixr_cfg_t * cfg)333 int MXC_SPIXR_Init(mxc_spixr_cfg_t *cfg)
334 {
335     MXC_SYS_ClockEnable(MXC_SYS_PERIPH_CLOCK_SCACHE);
336     MXC_TPU_Init(MXC_SYS_PERIPH_CLOCK_TPU);
337     MXC_SYS_ClockEnable(MXC_SYS_PERIPH_CLOCK_SPIXIPR);
338     MXC_GPIO_Config(&gpio_cfg_spixr);
339 
340     return MXC_SPIXR_RevA_Init((mxc_spixr_reva_regs_t *)MXC_SPIXR, (mxc_spixr_reva_cfg_t *)cfg);
341 }
342 
343 /* ************************************************************************* */
MXC_SPIXR_Shutdown(void)344 int MXC_SPIXR_Shutdown(void)
345 {
346     MXC_SYS_ClockDisable(MXC_SYS_PERIPH_CLOCK_SCACHE);
347     MXC_SYS_ClockDisable(MXC_SYS_PERIPH_CLOCK_SPIXIPR);
348     return E_NO_ERROR;
349 }
350 
351 /* ************************************************************************* */
MXC_SPIXR_SendCommand(uint8_t * cmd,uint32_t length,uint32_t tx_num_char)352 void MXC_SPIXR_SendCommand(uint8_t *cmd, uint32_t length, uint32_t tx_num_char)
353 {
354     MXC_SPIXR_RevA_SendCommand((mxc_spixr_reva_regs_t *)MXC_SPIXR, cmd, length, tx_num_char);
355 }
356