EFM32 Wonder Gecko Software Documentation  efm32wg-doc-4.2.1
em_ldma.h
Go to the documentation of this file.
1 /***************************************************************************/
33 #ifndef __SILICON_LABS_EM_LDMA_H__
34 #define __SILICON_LABS_EM_LDMA_H__
35 
36 #include "em_device.h"
37 
38 #if defined( LDMA_PRESENT ) && ( LDMA_COUNT == 1 )
39 
40 #include <stdbool.h>
41 
42 #ifdef __cplusplus
43 extern "C" {
44 #endif
45 
46 
47 /***************************************************************************/
52 /***************************************************************************/
57 /*******************************************************************************
58  ******************************** ENUMS ************************************
59  ******************************************************************************/
60 
65 typedef enum
66 {
67  ldmaCtrlBlockSizeUnit1 = _LDMA_CH_CTRL_BLOCKSIZE_UNIT1,
68  ldmaCtrlBlockSizeUnit2 = _LDMA_CH_CTRL_BLOCKSIZE_UNIT2,
69  ldmaCtrlBlockSizeUnit3 = _LDMA_CH_CTRL_BLOCKSIZE_UNIT3,
70  ldmaCtrlBlockSizeUnit4 = _LDMA_CH_CTRL_BLOCKSIZE_UNIT4,
71  ldmaCtrlBlockSizeUnit6 = _LDMA_CH_CTRL_BLOCKSIZE_UNIT6,
72  ldmaCtrlBlockSizeUnit8 = _LDMA_CH_CTRL_BLOCKSIZE_UNIT8,
73  ldmaCtrlBlockSizeUnit16 = _LDMA_CH_CTRL_BLOCKSIZE_UNIT16,
74  ldmaCtrlBlockSizeUnit32 = _LDMA_CH_CTRL_BLOCKSIZE_UNIT32,
75  ldmaCtrlBlockSizeUnit64 = _LDMA_CH_CTRL_BLOCKSIZE_UNIT64,
76  ldmaCtrlBlockSizeUnit128 = _LDMA_CH_CTRL_BLOCKSIZE_UNIT128,
77  ldmaCtrlBlockSizeUnit256 = _LDMA_CH_CTRL_BLOCKSIZE_UNIT256,
78  ldmaCtrlBlockSizeUnit512 = _LDMA_CH_CTRL_BLOCKSIZE_UNIT512,
79  ldmaCtrlBlockSizeUnit1024 = _LDMA_CH_CTRL_BLOCKSIZE_UNIT1024,
80  ldmaCtrlBlockSizeAll = _LDMA_CH_CTRL_BLOCKSIZE_ALL
81 } LDMA_CtrlBlockSize_t;
82 
84 typedef enum
85 {
86  ldmaCtrlStructTypeXfer = _LDMA_CH_CTRL_STRUCTTYPE_TRANSFER,
87  ldmaCtrlStructTypeSync = _LDMA_CH_CTRL_STRUCTTYPE_SYNCHRONIZE,
88  ldmaCtrlStructTypeWrite = _LDMA_CH_CTRL_STRUCTTYPE_WRITE
89 } LDMA_CtrlStructType_t;
90 
92 typedef enum
93 {
94  ldmaCtrlReqModeBlock = _LDMA_CH_CTRL_REQMODE_BLOCK,
95  ldmaCtrlReqModeAll = _LDMA_CH_CTRL_REQMODE_ALL
96 } LDMA_CtrlReqMode_t;
97 
99 typedef enum
100 {
101  ldmaCtrlSrcIncOne = _LDMA_CH_CTRL_SRCINC_ONE,
102  ldmaCtrlSrcIncTwo = _LDMA_CH_CTRL_SRCINC_TWO,
103  ldmaCtrlSrcIncFour = _LDMA_CH_CTRL_SRCINC_FOUR,
104  ldmaCtrlSrcIncNone = _LDMA_CH_CTRL_SRCINC_NONE
105 } LDMA_CtrlSrcInc_t;
106 
108 typedef enum
109 {
110  ldmaCtrlSizeByte = _LDMA_CH_CTRL_SIZE_BYTE,
111  ldmaCtrlSizeHalf = _LDMA_CH_CTRL_SIZE_HALFWORD,
112  ldmaCtrlSizeWord = _LDMA_CH_CTRL_SIZE_WORD
113 } LDMA_CtrlSize_t;
114 
116 typedef enum
117 {
118  ldmaCtrlDstIncOne = _LDMA_CH_CTRL_DSTINC_ONE,
119  ldmaCtrlDstIncTwo = _LDMA_CH_CTRL_DSTINC_TWO,
120  ldmaCtrlDstIncFour = _LDMA_CH_CTRL_DSTINC_FOUR,
121  ldmaCtrlDstIncNone = _LDMA_CH_CTRL_DSTINC_NONE
122 } LDMA_CtrlDstInc_t;
123 
125 typedef enum
126 {
127  ldmaCtrlSrcAddrModeAbs = _LDMA_CH_CTRL_SRCMODE_ABSOLUTE,
128  ldmaCtrlSrcAddrModeRel = _LDMA_CH_CTRL_SRCMODE_RELATIVE
129 } LDMA_CtrlSrcAddrMode_t;
130 
132 typedef enum
133 {
134  ldmaCtrlDstAddrModeAbs = _LDMA_CH_CTRL_DSTMODE_ABSOLUTE,
135  ldmaCtrlDstAddrModeRel = _LDMA_CH_CTRL_DSTMODE_RELATIVE
136 } LDMA_CtrlDstAddrMode_t;
137 
139 typedef enum
140 {
141  ldmaLinkModeAbs = _LDMA_CH_LINK_LINKMODE_ABSOLUTE,
142  ldmaLinkModeRel = _LDMA_CH_LINK_LINKMODE_RELATIVE
143 } LDMA_LinkMode_t;
144 
146 typedef enum
147 {
148  ldmaCfgArbSlotsAs1 = _LDMA_CH_CFG_ARBSLOTS_ONE,
149  ldmaCfgArbSlotsAs2 = _LDMA_CH_CFG_ARBSLOTS_TWO,
150  ldmaCfgArbSlotsAs4 = _LDMA_CH_CFG_ARBSLOTS_FOUR,
151  ldmaCfgArbSlotsAs8 = _LDMA_CH_CFG_ARBSLOTS_EIGHT
152 } LDMA_CfgArbSlots_t;
153 
155 typedef enum
156 {
157  ldmaCfgSrcIncSignPos = _LDMA_CH_CFG_SRCINCSIGN_POSITIVE,
158  ldmaCfgSrcIncSignNeg = _LDMA_CH_CFG_SRCINCSIGN_NEGATIVE
159 } LDMA_CfgSrcIncSign_t;
160 
162 typedef enum
163 {
164  ldmaCfgDstIncSignPos = _LDMA_CH_CFG_DSTINCSIGN_POSITIVE,
165  ldmaCfgDstIncSignNeg = _LDMA_CH_CFG_DSTINCSIGN_NEGATIVE
166 } LDMA_CfgDstIncSign_t;
167 
169 typedef enum
170 {
171  ldmaPeripheralSignal_NONE = LDMA_CH_REQSEL_SOURCESEL_NONE,
172  #if defined( LDMA_CH_REQSEL_SIGSEL_ADC0SCAN )
173  ldmaPeripheralSignal_ADC0_SCAN = LDMA_CH_REQSEL_SIGSEL_ADC0SCAN | LDMA_CH_REQSEL_SOURCESEL_ADC0,
174  #endif
175  #if defined( LDMA_CH_REQSEL_SIGSEL_ADC0SINGLE )
176  ldmaPeripheralSignal_ADC0_SINGLE = LDMA_CH_REQSEL_SIGSEL_ADC0SINGLE | LDMA_CH_REQSEL_SOURCESEL_ADC0,
177  #endif
178  #if defined( LDMA_CH_REQSEL_SIGSEL_AGCRSSI )
179  ldmaPeripheralSignal_AGC_RSSI = LDMA_CH_REQSEL_SIGSEL_AGCRSSI | LDMA_CH_REQSEL_SOURCESEL_AGC,
180  #endif
181  #if defined( LDMA_CH_REQSEL_SIGSEL_CRYPTODATA0RD )
182  ldmaPeripheralSignal_CRYPTO_DATA0RD = LDMA_CH_REQSEL_SIGSEL_CRYPTODATA0RD | LDMA_CH_REQSEL_SOURCESEL_CRYPTO,
183  #endif
184  #if defined( LDMA_CH_REQSEL_SIGSEL_CRYPTODATA0WR )
185  ldmaPeripheralSignal_CRYPTO_DATA0WR = LDMA_CH_REQSEL_SIGSEL_CRYPTODATA0WR | LDMA_CH_REQSEL_SOURCESEL_CRYPTO,
186  #endif
187  #if defined( LDMA_CH_REQSEL_SIGSEL_CRYPTODATA0XWR )
188  ldmaPeripheralSignal_CRYPTO_DATA0XWR = LDMA_CH_REQSEL_SIGSEL_CRYPTODATA0XWR | LDMA_CH_REQSEL_SOURCESEL_CRYPTO,
189  #endif
190  #if defined( LDMA_CH_REQSEL_SIGSEL_CRYPTODATA1RD )
191  ldmaPeripheralSignal_CRYPTO_DATA1RD = LDMA_CH_REQSEL_SIGSEL_CRYPTODATA1RD | LDMA_CH_REQSEL_SOURCESEL_CRYPTO,
192  #endif
193  #if defined( LDMA_CH_REQSEL_SIGSEL_CRYPTODATA1WR )
194  ldmaPeripheralSignal_CRYPTO_DATA1WR = LDMA_CH_REQSEL_SIGSEL_CRYPTODATA1WR | LDMA_CH_REQSEL_SOURCESEL_CRYPTO,
195  #endif
196  #if defined( LDMA_CH_REQSEL_SIGSEL_I2C0RXDATAV )
197  ldmaPeripheralSignal_I2C0_RXDATAV = LDMA_CH_REQSEL_SIGSEL_I2C0RXDATAV | LDMA_CH_REQSEL_SOURCESEL_I2C0,
198  #endif
199  #if defined( LDMA_CH_REQSEL_SIGSEL_I2C0TXBL )
200  ldmaPeripheralSignal_I2C0_TXBL = LDMA_CH_REQSEL_SIGSEL_I2C0TXBL | LDMA_CH_REQSEL_SOURCESEL_I2C0,
201  #endif
202  #if defined( LDMA_CH_REQSEL_SIGSEL_LEUART0RXDATAV )
203  ldmaPeripheralSignal_LEUART0_RXDATAV = LDMA_CH_REQSEL_SIGSEL_LEUART0RXDATAV | LDMA_CH_REQSEL_SOURCESEL_LEUART0,
204  #endif
205  #if defined( LDMA_CH_REQSEL_SIGSEL_LEUART0TXBL )
206  ldmaPeripheralSignal_LEUART0_TXBL = LDMA_CH_REQSEL_SIGSEL_LEUART0TXBL | LDMA_CH_REQSEL_SOURCESEL_LEUART0,
207  #endif
208  #if defined( LDMA_CH_REQSEL_SIGSEL_LEUART0TXEMPTY )
209  ldmaPeripheralSignal_LEUART0_TXEMPTY = LDMA_CH_REQSEL_SIGSEL_LEUART0TXEMPTY | LDMA_CH_REQSEL_SOURCESEL_LEUART0,
210  #endif
211  #if defined( LDMA_CH_REQSEL_SIGSEL_MODEMDEBUG )
212  ldmaPeripheralSignal_MODEM_DEBUG = LDMA_CH_REQSEL_SIGSEL_MODEMDEBUG | LDMA_CH_REQSEL_SOURCESEL_MODEM,
213  #endif
214  #if defined( LDMA_CH_REQSEL_SIGSEL_MSCWDATA )
215  ldmaPeripheralSignal_MSC_WDATA = LDMA_CH_REQSEL_SIGSEL_MSCWDATA | LDMA_CH_REQSEL_SOURCESEL_MSC,
216  #endif
217  #if defined( LDMA_CH_REQSEL_SIGSEL_PROTIMERBOF )
218  ldmaPeripheralSignal_PROTIMER_BOF = LDMA_CH_REQSEL_SIGSEL_PROTIMERBOF | LDMA_CH_REQSEL_SOURCESEL_PROTIMER,
219  #endif
220  #if defined( LDMA_CH_REQSEL_SIGSEL_PROTIMERCC0 )
221  ldmaPeripheralSignal_PROTIMER_CC0 = LDMA_CH_REQSEL_SIGSEL_PROTIMERCC0 | LDMA_CH_REQSEL_SOURCESEL_PROTIMER,
222  #endif
223  #if defined( LDMA_CH_REQSEL_SIGSEL_PROTIMERCC1 )
224  ldmaPeripheralSignal_PROTIMER_CC1 = LDMA_CH_REQSEL_SIGSEL_PROTIMERCC1 | LDMA_CH_REQSEL_SOURCESEL_PROTIMER,
225  #endif
226  #if defined( LDMA_CH_REQSEL_SIGSEL_PROTIMERCC2 )
227  ldmaPeripheralSignal_PROTIMER_CC2 = LDMA_CH_REQSEL_SIGSEL_PROTIMERCC2 | LDMA_CH_REQSEL_SOURCESEL_PROTIMER,
228  #endif
229  #if defined( LDMA_CH_REQSEL_SIGSEL_PROTIMERCC3 )
230  ldmaPeripheralSignal_PROTIMER_CC3 = LDMA_CH_REQSEL_SIGSEL_PROTIMERCC3 | LDMA_CH_REQSEL_SOURCESEL_PROTIMER,
231  #endif
232  #if defined( LDMA_CH_REQSEL_SIGSEL_PROTIMERCC4 )
233  ldmaPeripheralSignal_PROTIMER_CC4 = LDMA_CH_REQSEL_SIGSEL_PROTIMERCC4 | LDMA_CH_REQSEL_SOURCESEL_PROTIMER,
234  #endif
235  #if defined( LDMA_CH_REQSEL_SIGSEL_PROTIMERPOF )
236  ldmaPeripheralSignal_PROTIMER_POF = LDMA_CH_REQSEL_SIGSEL_PROTIMERPOF | LDMA_CH_REQSEL_SOURCESEL_PROTIMER,
237  #endif
238  #if defined( LDMA_CH_REQSEL_SIGSEL_PROTIMERWOF )
239  ldmaPeripheralSignal_PROTIMER_WOF = LDMA_CH_REQSEL_SIGSEL_PROTIMERWOF | LDMA_CH_REQSEL_SOURCESEL_PROTIMER,
240  #endif
241  #if defined( LDMA_CH_REQSEL_SIGSEL_PRSREQ0 )
242  ldmaPeripheralSignal_PRS_REQ0 = LDMA_CH_REQSEL_SIGSEL_PRSREQ0 | LDMA_CH_REQSEL_SOURCESEL_PRS,
243  #endif
244  #if defined( LDMA_CH_REQSEL_SIGSEL_PRSREQ1 )
245  ldmaPeripheralSignal_PRS_REQ1 = LDMA_CH_REQSEL_SIGSEL_PRSREQ1 | LDMA_CH_REQSEL_SOURCESEL_PRS,
246  #endif
247  #if defined( LDMA_CH_REQSEL_SIGSEL_TIMER0CC0 )
248  ldmaPeripheralSignal_TIMER0_CC0 = LDMA_CH_REQSEL_SIGSEL_TIMER0CC0 | LDMA_CH_REQSEL_SOURCESEL_TIMER0,
249  #endif
250  #if defined( LDMA_CH_REQSEL_SIGSEL_TIMER0CC1 )
251  ldmaPeripheralSignal_TIMER0_CC1 = LDMA_CH_REQSEL_SIGSEL_TIMER0CC1 | LDMA_CH_REQSEL_SOURCESEL_TIMER0,
252  #endif
253  #if defined( LDMA_CH_REQSEL_SIGSEL_TIMER0CC2 )
254  ldmaPeripheralSignal_TIMER0_CC2 = LDMA_CH_REQSEL_SIGSEL_TIMER0CC2 | LDMA_CH_REQSEL_SOURCESEL_TIMER0,
255  #endif
256  #if defined( LDMA_CH_REQSEL_SIGSEL_TIMER0UFOF )
257  ldmaPeripheralSignal_TIMER0_UFOF = LDMA_CH_REQSEL_SIGSEL_TIMER0UFOF | LDMA_CH_REQSEL_SOURCESEL_TIMER0,
258  #endif
259  #if defined( LDMA_CH_REQSEL_SIGSEL_TIMER1CC0 )
260  ldmaPeripheralSignal_TIMER1_CC0 = LDMA_CH_REQSEL_SIGSEL_TIMER1CC0 | LDMA_CH_REQSEL_SOURCESEL_TIMER1,
261  #endif
262  #if defined( LDMA_CH_REQSEL_SIGSEL_TIMER1CC1 )
263  ldmaPeripheralSignal_TIMER1_CC1 = LDMA_CH_REQSEL_SIGSEL_TIMER1CC1 | LDMA_CH_REQSEL_SOURCESEL_TIMER1,
264  #endif
265  #if defined( LDMA_CH_REQSEL_SIGSEL_TIMER1CC2 )
266  ldmaPeripheralSignal_TIMER1_CC2 = LDMA_CH_REQSEL_SIGSEL_TIMER1CC2 | LDMA_CH_REQSEL_SOURCESEL_TIMER1,
267  #endif
268  #if defined( LDMA_CH_REQSEL_SIGSEL_TIMER1CC3 )
269  ldmaPeripheralSignal_TIMER1_CC3 = LDMA_CH_REQSEL_SIGSEL_TIMER1CC3 | LDMA_CH_REQSEL_SOURCESEL_TIMER1,
270  #endif
271  #if defined( LDMA_CH_REQSEL_SIGSEL_TIMER1UFOF )
272  ldmaPeripheralSignal_TIMER1_UFOF = LDMA_CH_REQSEL_SIGSEL_TIMER1UFOF | LDMA_CH_REQSEL_SOURCESEL_TIMER1,
273  #endif
274  #if defined( LDMA_CH_REQSEL_SIGSEL_USART0RXDATAV )
275  ldmaPeripheralSignal_USART0_RXDATAV = LDMA_CH_REQSEL_SIGSEL_USART0RXDATAV | LDMA_CH_REQSEL_SOURCESEL_USART0,
276  #endif
277  #if defined( LDMA_CH_REQSEL_SIGSEL_USART0TXBL )
278  ldmaPeripheralSignal_USART0_TXBL = LDMA_CH_REQSEL_SIGSEL_USART0TXBL | LDMA_CH_REQSEL_SOURCESEL_USART0,
279  #endif
280  #if defined( LDMA_CH_REQSEL_SIGSEL_USART0TXEMPTY )
281  ldmaPeripheralSignal_USART0_TXEMPTY = LDMA_CH_REQSEL_SIGSEL_USART0TXEMPTY | LDMA_CH_REQSEL_SOURCESEL_USART0,
282  #endif
283  #if defined( LDMA_CH_REQSEL_SIGSEL_USART1RXDATAV )
284  ldmaPeripheralSignal_USART1_RXDATAV = LDMA_CH_REQSEL_SIGSEL_USART1RXDATAV | LDMA_CH_REQSEL_SOURCESEL_USART1,
285  #endif
286  #if defined( LDMA_CH_REQSEL_SIGSEL_USART1RXDATAVRIGHT )
287  ldmaPeripheralSignal_USART1_RXDATAVRIGHT = LDMA_CH_REQSEL_SIGSEL_USART1RXDATAVRIGHT | LDMA_CH_REQSEL_SOURCESEL_USART1,
288  #endif
289  #if defined( LDMA_CH_REQSEL_SIGSEL_USART1TXBL )
290  ldmaPeripheralSignal_USART1_TXBL = LDMA_CH_REQSEL_SIGSEL_USART1TXBL | LDMA_CH_REQSEL_SOURCESEL_USART1,
291  #endif
292  #if defined( LDMA_CH_REQSEL_SIGSEL_USART1TXBLRIGHT )
293  ldmaPeripheralSignal_USART1_TXBLRIGHT = LDMA_CH_REQSEL_SIGSEL_USART1TXBLRIGHT | LDMA_CH_REQSEL_SOURCESEL_USART1,
294  #endif
295  #if defined( LDMA_CH_REQSEL_SIGSEL_USART1TXEMPTY )
296  ldmaPeripheralSignal_USART1_TXEMPTY = LDMA_CH_REQSEL_SIGSEL_USART1TXEMPTY | LDMA_CH_REQSEL_SOURCESEL_USART1
297  #endif
298 } LDMA_PeripheralSignal_t;
299 
300 
301 /*******************************************************************************
302  ******************************* STRUCTS ***********************************
303  ******************************************************************************/
304 
314 typedef union
315 {
320  struct
321  {
322  uint32_t structType : 2;
323  uint32_t reserved0 : 1;
324  uint32_t structReq : 1;
325  uint32_t xferCnt : 11;
326  uint32_t byteSwap : 1;
327  uint32_t blockSize : 4;
328  uint32_t doneIfs : 1;
329  uint32_t reqMode : 1;
330  uint32_t decLoopCnt : 1;
331  uint32_t ignoreSrec : 1;
332  uint32_t srcInc : 2;
333  uint32_t size : 2;
334  uint32_t dstInc : 2;
335  uint32_t srcAddrMode: 1;
336  uint32_t dstAddrMode: 1;
338  uint32_t srcAddr;
339  uint32_t dstAddr;
341  uint32_t linkMode : 1;
342  uint32_t link : 1;
343  int32_t linkAddr : 30;
344  } xfer;
345 
349  struct
350  {
351  uint32_t structType : 2;
352  uint32_t reserved0 : 1;
353  uint32_t structReq : 1;
354  uint32_t xferCnt : 11;
355  uint32_t byteSwap : 1;
356  uint32_t blockSize : 4;
357  uint32_t doneIfs : 1;
358  uint32_t reqMode : 1;
359  uint32_t decLoopCnt : 1;
360  uint32_t ignoreSrec : 1;
361  uint32_t srcInc : 2;
362  uint32_t size : 2;
363  uint32_t dstInc : 2;
364  uint32_t srcAddrMode: 1;
365  uint32_t dstAddrMode: 1;
367  uint32_t syncSet : 8;
368  uint32_t syncClr : 8;
369  uint32_t reserved3 : 16;
370  uint32_t matchVal : 8;
371  uint32_t matchEn : 8;
372  uint32_t reserved4 : 16;
373 
374  uint32_t linkMode : 1;
375  uint32_t link : 1;
376  int32_t linkAddr : 30;
377  } sync;
378 
380  struct
381  {
382  uint32_t structType : 2;
383  uint32_t reserved0 : 1;
384  uint32_t structReq : 1;
385  uint32_t xferCnt : 11;
386  uint32_t byteSwap : 1;
387  uint32_t blockSize : 4;
388  uint32_t doneIfs : 1;
389  uint32_t reqMode : 1;
390  uint32_t decLoopCnt : 1;
391  uint32_t ignoreSrec : 1;
392  uint32_t srcInc : 2;
393  uint32_t size : 2;
394  uint32_t dstInc : 2;
395  uint32_t srcAddrMode: 1;
396  uint32_t dstAddrMode: 1;
398  uint32_t immVal;
399  uint32_t dstAddr;
401  uint32_t linkMode : 1;
402  uint32_t link : 1;
403  int32_t linkAddr : 30;
404  } wri;
405 } LDMA_Descriptor_t;
406 
408 typedef struct
409 {
410  uint8_t ldmaInitCtrlNumFixed;
411  uint8_t ldmaInitCtrlSyncPrsClrEn;
412  uint8_t ldmaInitCtrlSyncPrsSetEn;
413  uint8_t ldmaInitIrqPriority;
414 } LDMA_Init_t;
415 
422 typedef struct
423 {
424  uint32_t ldmaReqSel;
425  uint8_t ldmaCtrlSyncPrsClrOff;
426  uint8_t ldmaCtrlSyncPrsClrOn;
427  uint8_t ldmaCtrlSyncPrsSetOff;
428  uint8_t ldmaCtrlSyncPrsSetOn;
429  bool ldmaReqDis;
430  bool ldmaDbgHalt;
431  uint8_t ldmaCfgArbSlots;
432  uint8_t ldmaCfgSrcIncSign;
433  uint8_t ldmaCfgDstIncSign;
434  uint8_t ldmaLoopCnt;
435 } LDMA_TransferCfg_t;
436 
437 
438 /*******************************************************************************
439  ************************** STRUCT INITIALIZERS ****************************
440  ******************************************************************************/
441 
442 
444 #define LDMA_INIT_DEFAULT \
445 { \
446  .ldmaInitCtrlNumFixed = _LDMA_CTRL_NUMFIXED_DEFAULT, /* Fixed priority arbitration. */ \
447  .ldmaInitCtrlSyncPrsClrEn = 0, /* No PRS Synctrig clear enable*/ \
448  .ldmaInitCtrlSyncPrsSetEn = 0, /* No PRS Synctrig set enable. */ \
449  .ldmaInitIrqPriority = 3 /* IRQ priority level 3. */ \
450 }
451 
456 #define LDMA_TRANSFER_CFG_MEMORY() \
457 { \
458  0, 0, 0, 0, 0, \
459  false, false, ldmaCfgArbSlotsAs1, \
460  ldmaCfgSrcIncSignPos, ldmaCfgDstIncSignPos, 0 \
461 }
462 
467 #define LDMA_TRANSFER_CFG_MEMORY_LOOP( loopCnt) \
468 { \
469  0, 0, 0, 0, 0, \
470  false, false, ldmaCfgArbSlotsAs1, \
471  ldmaCfgSrcIncSignPos, ldmaCfgDstIncSignPos, \
472  loopCnt \
473 }
474 
479 #define LDMA_TRANSFER_CFG_PERIPHERAL( signal ) \
480 { \
481  signal, 0, 0, 0, 0, \
482  false, false, ldmaCfgArbSlotsAs1, \
483  ldmaCfgSrcIncSignPos, ldmaCfgDstIncSignPos, 0 \
484 }
485 
490 #define LDMA_TRANSFER_CFG_PERIPHERAL_LOOP( signal, loopCnt ) \
491 { \
492  signal, 0, 0, 0, 0, \
493  false, false, ldmaCfgArbSlotsAs1, \
494  ldmaCfgSrcIncSignPos, ldmaCfgDstIncSignPos, loopCnt \
495 }
496 
504 #define LDMA_DESCRIPTOR_SINGLE_M2M_WORD( src, dest, count ) \
505 { \
506  .xfer = \
507  { \
508  .structType = ldmaCtrlStructTypeXfer, \
509  .structReq = 1, \
510  .xferCnt = ( count ) - 1, \
511  .byteSwap = 0, \
512  .blockSize = ldmaCtrlBlockSizeUnit1, \
513  .doneIfs = 1, \
514  .reqMode = ldmaCtrlReqModeAll, \
515  .decLoopCnt = 0, \
516  .ignoreSrec = 0, \
517  .srcInc = ldmaCtrlSrcIncOne, \
518  .size = ldmaCtrlSizeWord, \
519  .dstInc = ldmaCtrlDstIncOne, \
520  .srcAddrMode = ldmaCtrlSrcAddrModeAbs, \
521  .dstAddrMode = ldmaCtrlDstAddrModeAbs, \
522  .srcAddr = (uint32_t)(src), \
523  .dstAddr = (uint32_t)(dest), \
524  .linkMode = 0, \
525  .link = 0, \
526  .linkAddr = 0 \
527  } \
528 }
529 
537 #define LDMA_DESCRIPTOR_SINGLE_M2M_HALF( src, dest, count ) \
538 { \
539  .xfer = \
540  { \
541  .structType = ldmaCtrlStructTypeXfer, \
542  .structReq = 1, \
543  .xferCnt = ( count ) - 1, \
544  .byteSwap = 0, \
545  .blockSize = ldmaCtrlBlockSizeUnit1, \
546  .doneIfs = 1, \
547  .reqMode = ldmaCtrlReqModeAll, \
548  .decLoopCnt = 0, \
549  .ignoreSrec = 0, \
550  .srcInc = ldmaCtrlSrcIncOne, \
551  .size = ldmaCtrlSizeHalf, \
552  .dstInc = ldmaCtrlDstIncOne, \
553  .srcAddrMode = ldmaCtrlSrcAddrModeAbs, \
554  .dstAddrMode = ldmaCtrlDstAddrModeAbs, \
555  .srcAddr = (uint32_t)(src), \
556  .dstAddr = (uint32_t)(dest), \
557  .linkMode = 0, \
558  .link = 0, \
559  .linkAddr = 0 \
560  } \
561 }
562 
570 #define LDMA_DESCRIPTOR_SINGLE_M2M_BYTE( src, dest, count ) \
571 { \
572  .xfer = \
573  { \
574  .structType = ldmaCtrlStructTypeXfer, \
575  .structReq = 1, \
576  .xferCnt = ( count ) - 1, \
577  .byteSwap = 0, \
578  .blockSize = ldmaCtrlBlockSizeUnit1, \
579  .doneIfs = 1, \
580  .reqMode = ldmaCtrlReqModeAll, \
581  .decLoopCnt = 0, \
582  .ignoreSrec = 0, \
583  .srcInc = ldmaCtrlSrcIncOne, \
584  .size = ldmaCtrlSizeByte, \
585  .dstInc = ldmaCtrlDstIncOne, \
586  .srcAddrMode = ldmaCtrlSrcAddrModeAbs, \
587  .dstAddrMode = ldmaCtrlDstAddrModeAbs, \
588  .srcAddr = (uint32_t)(src), \
589  .dstAddr = (uint32_t)(dest), \
590  .linkMode = 0, \
591  .link = 0, \
592  .linkAddr = 0 \
593  } \
594 }
595 
608 #define LDMA_DESCRIPTOR_LINKABS_M2M_WORD( src, dest, count ) \
609 { \
610  .xfer = \
611  { \
612  .structType = ldmaCtrlStructTypeXfer, \
613  .structReq = 1, \
614  .xferCnt = ( count ) - 1, \
615  .byteSwap = 0, \
616  .blockSize = ldmaCtrlBlockSizeUnit1, \
617  .doneIfs = 0, \
618  .reqMode = ldmaCtrlReqModeAll, \
619  .decLoopCnt = 0, \
620  .ignoreSrec = 0, \
621  .srcInc = ldmaCtrlSrcIncOne, \
622  .size = ldmaCtrlSizeWord, \
623  .dstInc = ldmaCtrlDstIncOne, \
624  .srcAddrMode = ldmaCtrlSrcAddrModeAbs, \
625  .dstAddrMode = ldmaCtrlDstAddrModeAbs, \
626  .srcAddr = (uint32_t)(src), \
627  .dstAddr = (uint32_t)(dest), \
628  .linkMode = ldmaLinkModeAbs, \
629  .link = 1, \
630  .linkAddr = 0 /* Must be set runtime ! */ \
631  } \
632 }
633 
646 #define LDMA_DESCRIPTOR_LINKABS_M2M_HALF( src, dest, count ) \
647 { \
648  .xfer = \
649  { \
650  .structType = ldmaCtrlStructTypeXfer, \
651  .structReq = 1, \
652  .xferCnt = ( count ) - 1, \
653  .byteSwap = 0, \
654  .blockSize = ldmaCtrlBlockSizeUnit1, \
655  .doneIfs = 0, \
656  .reqMode = ldmaCtrlReqModeAll, \
657  .decLoopCnt = 0, \
658  .ignoreSrec = 0, \
659  .srcInc = ldmaCtrlSrcIncOne, \
660  .size = ldmaCtrlSizeHalf, \
661  .dstInc = ldmaCtrlDstIncOne, \
662  .srcAddrMode = ldmaCtrlSrcAddrModeAbs, \
663  .dstAddrMode = ldmaCtrlDstAddrModeAbs, \
664  .srcAddr = (uint32_t)(src), \
665  .dstAddr = (uint32_t)(dest), \
666  .linkMode = ldmaLinkModeAbs, \
667  .link = 1, \
668  .linkAddr = 0 /* Must be set runtime ! */ \
669  } \
670 }
671 
684 #define LDMA_DESCRIPTOR_LINKABS_M2M_BYTE( src, dest, count ) \
685 { \
686  .xfer = \
687  { \
688  .structType = ldmaCtrlStructTypeXfer, \
689  .structReq = 1, \
690  .xferCnt = ( count ) - 1, \
691  .byteSwap = 0, \
692  .blockSize = ldmaCtrlBlockSizeUnit1, \
693  .doneIfs = 0, \
694  .reqMode = ldmaCtrlReqModeAll, \
695  .decLoopCnt = 0, \
696  .ignoreSrec = 0, \
697  .srcInc = ldmaCtrlSrcIncOne, \
698  .size = ldmaCtrlSizeByte, \
699  .dstInc = ldmaCtrlDstIncOne, \
700  .srcAddrMode = ldmaCtrlSrcAddrModeAbs, \
701  .dstAddrMode = ldmaCtrlDstAddrModeAbs, \
702  .srcAddr = (uint32_t)(src), \
703  .dstAddr = (uint32_t)(dest), \
704  .linkMode = ldmaLinkModeAbs, \
705  .link = 1, \
706  .linkAddr = 0 /* Must be set runtime ! */ \
707  } \
708 }
709 
728 #define LDMA_DESCRIPTOR_LINKREL_M2M_WORD( src, dest, count, linkjmp ) \
729 { \
730  .xfer = \
731  { \
732  .structType = ldmaCtrlStructTypeXfer, \
733  .structReq = 1, \
734  .xferCnt = ( count ) - 1, \
735  .byteSwap = 0, \
736  .blockSize = ldmaCtrlBlockSizeUnit1, \
737  .doneIfs = 0, \
738  .reqMode = ldmaCtrlReqModeAll, \
739  .decLoopCnt = 0, \
740  .ignoreSrec = 0, \
741  .srcInc = ldmaCtrlSrcIncOne, \
742  .size = ldmaCtrlSizeWord, \
743  .dstInc = ldmaCtrlDstIncOne, \
744  .srcAddrMode = ldmaCtrlSrcAddrModeAbs, \
745  .dstAddrMode = ldmaCtrlDstAddrModeAbs, \
746  .srcAddr = (uint32_t)(src), \
747  .dstAddr = (uint32_t)(dest), \
748  .linkMode = ldmaLinkModeRel, \
749  .link = 1, \
750  .linkAddr = ( linkjmp ) * 4 \
751  } \
752 }
753 
772 #define LDMA_DESCRIPTOR_LINKREL_M2M_HALF( src, dest, count, linkjmp ) \
773 { \
774  .xfer = \
775  { \
776  .structType = ldmaCtrlStructTypeXfer, \
777  .structReq = 1, \
778  .xferCnt = ( count ) - 1, \
779  .byteSwap = 0, \
780  .blockSize = ldmaCtrlBlockSizeUnit1, \
781  .doneIfs = 0, \
782  .reqMode = ldmaCtrlReqModeAll, \
783  .decLoopCnt = 0, \
784  .ignoreSrec = 0, \
785  .srcInc = ldmaCtrlSrcIncOne, \
786  .size = ldmaCtrlSizeHalf, \
787  .dstInc = ldmaCtrlDstIncOne, \
788  .srcAddrMode = ldmaCtrlSrcAddrModeAbs, \
789  .dstAddrMode = ldmaCtrlDstAddrModeAbs, \
790  .srcAddr = (uint32_t)(src), \
791  .dstAddr = (uint32_t)(dest), \
792  .linkMode = ldmaLinkModeRel, \
793  .link = 1, \
794  .linkAddr = ( linkjmp ) * 4 \
795  } \
796 }
797 
816 #define LDMA_DESCRIPTOR_LINKREL_M2M_BYTE( src, dest, count, linkjmp ) \
817 { \
818  .xfer = \
819  { \
820  .structType = ldmaCtrlStructTypeXfer, \
821  .structReq = 1, \
822  .xferCnt = ( count ) - 1, \
823  .byteSwap = 0, \
824  .blockSize = ldmaCtrlBlockSizeUnit1, \
825  .doneIfs = 0, \
826  .reqMode = ldmaCtrlReqModeAll, \
827  .decLoopCnt = 0, \
828  .ignoreSrec = 0, \
829  .srcInc = ldmaCtrlSrcIncOne, \
830  .size = ldmaCtrlSizeByte, \
831  .dstInc = ldmaCtrlDstIncOne, \
832  .srcAddrMode = ldmaCtrlSrcAddrModeAbs, \
833  .dstAddrMode = ldmaCtrlDstAddrModeAbs, \
834  .srcAddr = (uint32_t)(src), \
835  .dstAddr = (uint32_t)(dest), \
836  .linkMode = ldmaLinkModeRel, \
837  .link = 1, \
838  .linkAddr = ( linkjmp ) * 4 \
839  } \
840 }
841 
849 #define LDMA_DESCRIPTOR_SINGLE_P2M_BYTE( src, dest, count ) \
850 { \
851  .xfer = \
852  { \
853  .structType = ldmaCtrlStructTypeXfer, \
854  .structReq = 0, \
855  .xferCnt = ( count ) - 1, \
856  .byteSwap = 0, \
857  .blockSize = ldmaCtrlBlockSizeUnit1, \
858  .doneIfs = 1, \
859  .reqMode = ldmaCtrlReqModeBlock, \
860  .decLoopCnt = 0, \
861  .ignoreSrec = 0, \
862  .srcInc = ldmaCtrlSrcIncNone, \
863  .size = ldmaCtrlSizeByte, \
864  .dstInc = ldmaCtrlDstIncOne, \
865  .srcAddrMode = ldmaCtrlSrcAddrModeAbs, \
866  .dstAddrMode = ldmaCtrlDstAddrModeAbs, \
867  .srcAddr = (uint32_t)(src), \
868  .dstAddr = (uint32_t)(dest), \
869  .linkMode = 0, \
870  .link = 0, \
871  .linkAddr = 0 \
872  } \
873 }
874 
882 #define LDMA_DESCRIPTOR_SINGLE_M2P_BYTE( src, dest, count ) \
883 { \
884  .xfer = \
885  { \
886  .structType = ldmaCtrlStructTypeXfer, \
887  .structReq = 0, \
888  .xferCnt = ( count ) - 1, \
889  .byteSwap = 0, \
890  .blockSize = ldmaCtrlBlockSizeUnit1, \
891  .doneIfs = 1, \
892  .reqMode = ldmaCtrlReqModeBlock, \
893  .decLoopCnt = 0, \
894  .ignoreSrec = 0, \
895  .srcInc = ldmaCtrlSrcIncOne, \
896  .size = ldmaCtrlSizeByte, \
897  .dstInc = ldmaCtrlDstIncNone, \
898  .srcAddrMode = ldmaCtrlSrcAddrModeAbs, \
899  .dstAddrMode = ldmaCtrlDstAddrModeAbs, \
900  .srcAddr = (uint32_t)(src), \
901  .dstAddr = (uint32_t)(dest), \
902  .linkMode = 0, \
903  .link = 0, \
904  .linkAddr = 0 \
905  } \
906 }
907 
920 #define LDMA_DESCRIPTOR_LINKREL_P2M_BYTE( src, dest, count, linkjmp ) \
921 { \
922  .xfer = \
923  { \
924  .structType = ldmaCtrlStructTypeXfer, \
925  .structReq = 0, \
926  .xferCnt = ( count ) - 1, \
927  .byteSwap = 0, \
928  .blockSize = ldmaCtrlBlockSizeUnit1, \
929  .doneIfs = 1, \
930  .reqMode = ldmaCtrlReqModeBlock, \
931  .decLoopCnt = 0, \
932  .ignoreSrec = 0, \
933  .srcInc = ldmaCtrlSrcIncNone, \
934  .size = ldmaCtrlSizeByte, \
935  .dstInc = ldmaCtrlDstIncOne, \
936  .srcAddrMode = ldmaCtrlSrcAddrModeAbs, \
937  .dstAddrMode = ldmaCtrlDstAddrModeAbs, \
938  .srcAddr = (uint32_t)(src), \
939  .dstAddr = (uint32_t)(dest), \
940  .linkMode = ldmaLinkModeRel, \
941  .link = 1, \
942  .linkAddr = ( linkjmp ) * 4 \
943  } \
944 }
945 
958 #define LDMA_DESCRIPTOR_LINKREL_M2P_BYTE( src, dest, count, linkjmp ) \
959 { \
960  .xfer = \
961  { \
962  .structType = ldmaCtrlStructTypeXfer, \
963  .structReq = 0, \
964  .xferCnt = ( count ) - 1, \
965  .byteSwap = 0, \
966  .blockSize = ldmaCtrlBlockSizeUnit1, \
967  .doneIfs = 1, \
968  .reqMode = ldmaCtrlReqModeBlock, \
969  .decLoopCnt = 0, \
970  .ignoreSrec = 0, \
971  .srcInc = ldmaCtrlSrcIncOne, \
972  .size = ldmaCtrlSizeByte, \
973  .dstInc = ldmaCtrlDstIncNone, \
974  .srcAddrMode = ldmaCtrlSrcAddrModeAbs, \
975  .dstAddrMode = ldmaCtrlDstAddrModeAbs, \
976  .srcAddr = (uint32_t)(src), \
977  .dstAddr = (uint32_t)(dest), \
978  .linkMode = ldmaLinkModeRel, \
979  .link = 1, \
980  .linkAddr = ( linkjmp ) * 4 \
981  } \
982 }
983 
990 #define LDMA_DESCRIPTOR_SINGLE_WRITE( value, address ) \
991 { \
992  .wri = \
993  { \
994  .structType = ldmaCtrlStructTypeWrite, \
995  .structReq = 1, \
996  .xferCnt = 0, \
997  .byteSwap = 0, \
998  .blockSize = 0, \
999  .doneIfs = 1, \
1000  .reqMode = 0, \
1001  .decLoopCnt = 0, \
1002  .ignoreSrec = 0, \
1003  .srcInc = 0, \
1004  .size = 0, \
1005  .dstInc = 0, \
1006  .srcAddrMode = 0, \
1007  .dstAddrMode = 0, \
1008  .immVal = (value), \
1009  .dstAddr = (uint32_t)(address), \
1010  .linkMode = 0, \
1011  .link = 0, \
1012  .linkAddr = 0 \
1013  } \
1014 }
1015 
1027 #define LDMA_DESCRIPTOR_LINKABS_WRITE( value, address ) \
1028 { \
1029  .wri = \
1030  { \
1031  .structType = ldmaCtrlStructTypeWrite, \
1032  .structReq = 1, \
1033  .xferCnt = 0, \
1034  .byteSwap = 0, \
1035  .blockSize = 0, \
1036  .doneIfs = 0, \
1037  .reqMode = 0, \
1038  .decLoopCnt = 0, \
1039  .ignoreSrec = 0, \
1040  .srcInc = 0, \
1041  .size = 0, \
1042  .dstInc = 0, \
1043  .srcAddrMode = 0, \
1044  .dstAddrMode = 0, \
1045  .immVal = (value), \
1046  .dstAddr = (uint32_t)(address), \
1047  .linkMode = ldmaLinkModeAbs, \
1048  .link = 1, \
1049  .linkAddr = 0 /* Must be set runtime ! */ \
1050  } \
1051 }
1052 
1064 #define LDMA_DESCRIPTOR_LINKREL_WRITE( value, address, linkjmp ) \
1065 { \
1066  .wri = \
1067  { \
1068  .structType = ldmaCtrlStructTypeWrite, \
1069  .structReq = 1, \
1070  .xferCnt = 0, \
1071  .byteSwap = 0, \
1072  .blockSize = 0, \
1073  .doneIfs = 0, \
1074  .reqMode = 0, \
1075  .decLoopCnt = 0, \
1076  .ignoreSrec = 0, \
1077  .srcInc = 0, \
1078  .size = 0, \
1079  .dstInc = 0, \
1080  .srcAddrMode = 0, \
1081  .dstAddrMode = 0, \
1082  .immVal = (value), \
1083  .dstAddr = (uint32_t)(address), \
1084  .linkMode = ldmaLinkModeRel, \
1085  .link = 1, \
1086  .linkAddr = ( linkjmp ) * 4 \
1087  } \
1088 }
1089 
1098 #define LDMA_DESCRIPTOR_SINGLE_SYNC( set, clr, matchValue, matchEnable ) \
1099 { \
1100  .sync = \
1101  { \
1102  .structType = ldmaCtrlStructTypeSync, \
1103  .structReq = 1, \
1104  .xferCnt = 0, \
1105  .byteSwap = 0, \
1106  .blockSize = 0, \
1107  .doneIfs = 1, \
1108  .reqMode = 0, \
1109  .decLoopCnt = 0, \
1110  .ignoreSrec = 0, \
1111  .srcInc = 0, \
1112  .size = 0, \
1113  .dstInc = 0, \
1114  .srcAddrMode = 0, \
1115  .dstAddrMode = 0, \
1116  .syncSet = (set), \
1117  .syncClr = (clr), \
1118  .matchVal = (matchValue), \
1119  .matchEn = (matchEnable), \
1120  .linkMode = 0, \
1121  .link = 0, \
1122  .linkAddr = 0 \
1123  } \
1124 }
1125 
1139 #define LDMA_DESCRIPTOR_LINKABS_SYNC( set, clr, matchValue, matchEnable ) \
1140 { \
1141  .sync = \
1142  { \
1143  .structType = ldmaCtrlStructTypeSync, \
1144  .structReq = 1, \
1145  .xferCnt = 0, \
1146  .byteSwap = 0, \
1147  .blockSize = 0, \
1148  .doneIfs = 0, \
1149  .reqMode = 0, \
1150  .decLoopCnt = 0, \
1151  .ignoreSrec = 0, \
1152  .srcInc = 0, \
1153  .size = 0, \
1154  .dstInc = 0, \
1155  .srcAddrMode = 0, \
1156  .dstAddrMode = 0, \
1157  .syncSet = (set), \
1158  .syncClr = (clr), \
1159  .matchVal = (matchValue), \
1160  .matchEn = (matchEnable), \
1161  .linkMode = ldmaLinkModeAbs, \
1162  .link = 1, \
1163  .linkAddr = 0 /* Must be set runtime ! */ \
1164  } \
1165 }
1166 
1180 #define LDMA_DESCRIPTOR_LINKREL_SYNC( set, clr, matchValue, matchEnable, linkjmp ) \
1181 { \
1182  .sync = \
1183  { \
1184  .structType = ldmaCtrlStructTypeSync, \
1185  .structReq = 1, \
1186  .xferCnt = 0, \
1187  .byteSwap = 0, \
1188  .blockSize = 0, \
1189  .doneIfs = 0, \
1190  .reqMode = 0, \
1191  .decLoopCnt = 0, \
1192  .ignoreSrec = 0, \
1193  .srcInc = 0, \
1194  .size = 0, \
1195  .dstInc = 0, \
1196  .srcAddrMode = 0, \
1197  .dstAddrMode = 0, \
1198  .syncSet = (set), \
1199  .syncClr = (clr), \
1200  .matchVal = (matchValue), \
1201  .matchEn = (matchEnable), \
1202  .linkMode = ldmaLinkModeRel, \
1203  .link = 1, \
1204  .linkAddr = ( linkjmp ) * 4 \
1205  } \
1206 }
1207 
1208 /*******************************************************************************
1209  ***************************** PROTOTYPES **********************************
1210  ******************************************************************************/
1211 
1212 void LDMA_DeInit( void );
1213 void LDMA_Init( LDMA_Init_t *init );
1214 void LDMA_StartTransfer( int ch,
1215  LDMA_TransferCfg_t *transfer,
1216  LDMA_Descriptor_t *descriptor );
1217 void LDMA_StopTransfer( int ch );
1218 bool LDMA_TransferDone( int ch );
1219 uint32_t LDMA_TransferRemainingCount( int ch );
1220 
1221 
1222 /***************************************************************************/
1230 __STATIC_INLINE void LDMA_IntClear(uint32_t flags)
1231 {
1232  LDMA->IFC = flags;
1233 }
1234 
1235 
1236 /***************************************************************************/
1244 __STATIC_INLINE void LDMA_IntDisable(uint32_t flags)
1245 {
1246  LDMA->IEN &= ~flags;
1247 }
1248 
1249 
1250 /***************************************************************************/
1263 __STATIC_INLINE void LDMA_IntEnable(uint32_t flags)
1264 {
1265  LDMA->IEN |= flags;
1266 }
1267 
1268 
1269 /***************************************************************************/
1280 __STATIC_INLINE uint32_t LDMA_IntGet(void)
1281 {
1282  return LDMA->IF;
1283 }
1284 
1285 
1286 /***************************************************************************/
1300 __STATIC_INLINE uint32_t LDMA_IntGetEnabled(void)
1301 {
1302  uint32_t ien;
1303 
1304  ien = LDMA->IEN;
1305  return LDMA->IF & ien;
1306 }
1307 
1308 
1309 /***************************************************************************/
1317 __STATIC_INLINE void LDMA_IntSet(uint32_t flags)
1318 {
1319  LDMA->IFS = flags;
1320 }
1321 
1325 #ifdef __cplusplus
1326 }
1327 #endif
1328 
1329 #endif /* defined( LDMA_PRESENT ) && ( LDMA_COUNT == 1 ) */
1330 #endif /* __SILICON_LABS_EM_LDMA_H__ */
CMSIS Cortex-M Peripheral Access Layer for Silicon Laboratories microcontroller devices.