1 /*---------------------------------------------------------------------------*
2 Project: TwlSDK - MI - include
3 File: dma.h
4
5 Copyright 2003-2009 Nintendo. All rights reserved.
6
7 These coded instructions, statements, and computer programs contain
8 proprietary information of Nintendo of America Inc. and/or Nintendo
9 Company Ltd., and are protected by Federal copyright law. They may
10 not be disclosed to third parties or copied or duplicated in any form,
11 in whole or in part, without the prior written consent of Nintendo.
12
13 $Date:: 2009-06-04#$
14 $Rev: 10698 $
15 $Author: okubata_ryoma $
16 *---------------------------------------------------------------------------*/
17
18 #ifndef NITRO_MI_DMA_H_
19 #define NITRO_MI_DMA_H_
20
21 #ifdef __cplusplus
22 extern "C" {
23 #endif
24
25 #include <nitro/misc.h>
26 #include <nitro/types.h>
27 #ifndef SDK_TWL
28 #include <nitro/memorymap.h>
29 #endif
30
31 //================================================================================
32 // DMA control definition
33 //================================================================================
34 //---- maximum DMA channel No.
35 #define MI_DMA_MAX_NUM 3
36
37 // utility constants for high-level libraries (CARD, FS, ...)
38 #define MI_DMA_CHANNEL_MASK 0x00000003UL
39 #define MI_DMA_NOT_USE 0xFFFFFFFFUL
40 #define MI_DMA_USING_NEW 0x00000010UL
41 #define MI_DMA_USING_FORMER 0x00000000UL
42
43 //---- enable
44 #define MI_DMA_ENABLE (1UL << REG_MI_DMA0CNT_E_SHIFT) // DMA enable
45 #define MI_DMA_DISABLE (0UL << REG_MI_DMA0CNT_E_SHIFT) // DMA enable
46 #define MI_DMA_IF_ENABLE (1UL << REG_MI_DMA0CNT_I_SHIFT) // interrupt enable
47 #define MI_DMA_IF_DISABLE (0UL << REG_MI_DMA0CNT_I_SHIFT) // interrupt enable
48
49 //---- DMA timing
50 #ifdef SDK_ARM9
51 # define MI_DMA_TIMING_MASK (REG_MI_DMA0CNT_MODE_MASK) // mask of start field
52 # define MI_DMA_TIMING_SHIFT (REG_MI_DMA0CNT_MODE_SHIFT) // shift of start field
53 # define MI_DMA_TIMING_IMM (0UL << REG_MI_DMA0CNT_MODE_SHIFT) // start immediately
54 # define MI_DMA_TIMING_V_BLANK (1UL << REG_MI_DMA0CNT_MODE_SHIFT) // start by VBlank
55 # define MI_DMA_TIMING_H_BLANK (2UL << REG_MI_DMA0CNT_MODE_SHIFT) // start by HBlank
56 # define MI_DMA_TIMING_DISP (3UL << REG_MI_DMA0CNT_MODE_SHIFT) // display sync
57 # define MI_DMA_TIMING_DISP_MMEM (4UL << REG_MI_DMA0CNT_MODE_SHIFT) // main memory display sync
58 # define MI_DMA_TIMING_CARD (5UL << REG_MI_DMA0CNT_MODE_SHIFT) // card
59 # define MI_DMA_TIMING_CARTRIDGE (6UL << REG_MI_DMA0CNT_MODE_SHIFT) // cartridge
60 # define MI_DMA_TIMING_GXFIFO (7UL << REG_MI_DMA0CNT_MODE_SHIFT) // geometry FIFO
61 # define MIi_DMA_TIMING_ANY (u32)(~0) // for internal use (MIi_CardDmaCopy32)
62 #else // SDK_ARM9
63 # define MI_DMA_TIMING_MASK (REG_MI_DMA0CNT_TIMING_MASK) // mask of start field
64 # define MI_DMA_TIMING_SHIFT (REG_MI_DMA0CNT_TIMING_SHIFT) // shift of start field
65 # define MI_DMA_TIMING_IMM (0UL << REG_MI_DMA0CNT_TIMING_SHIFT) // start immediately
66 # define MI_DMA_TIMING_V_BLANK (1UL << REG_MI_DMA0CNT_TIMING_SHIFT) // start by VBlank
67 # define MI_DMA_TIMING_CARD (2UL << REG_MI_DMA0CNT_TIMING_SHIFT) // card
68 # define MI_DMA_TIMING_WIRELESS (3UL << REG_MI_DMA0CNT_TIMING_SHIFT) // DMA0,2:wireless interrupt
69 # define MI_DMA_TIMING_CARTRIDGE MI_DMA_TIMING_WIRELESS // DMA1,3:cartridge warning
70 #endif //SDK_ARM9
71
72 //---- DMA bus width
73 #define MI_DMA_16BIT_BUS (0UL << REG_MI_DMA0CNT_SB_SHIFT) // 16bit width
74 #define MI_DMA_32BIT_BUS (1UL << REG_MI_DMA0CNT_SB_SHIFT) // 32bit width
75
76 //---- continuous mode
77 #define MI_DMA_CONTINUOUS_OFF (0UL << REG_MI_DMA0CNT_CM_SHIFT) // continuous mode off
78 #define MI_DMA_CONTINUOUS_ON (1UL << REG_MI_DMA0CNT_CM_SHIFT) // continuous mode on
79
80 //---- direction of src/destination address
81 #define MI_DMA_SRC_INC (0UL << REG_MI_DMA0CNT_SAR_SHIFT) // increment source address
82 #define MI_DMA_SRC_DEC (1UL << REG_MI_DMA0CNT_SAR_SHIFT) // decrement source address
83 #define MI_DMA_SRC_FIX (2UL << REG_MI_DMA0CNT_SAR_SHIFT) // fix source address
84 #define MI_DMA_DEST_INC (0UL << REG_MI_DMA0CNT_DAR_SHIFT) // imcrement destination address
85 #define MI_DMA_DEST_DEC (1UL << REG_MI_DMA0CNT_DAR_SHIFT) // decrement destination address
86 #define MI_DMA_DEST_FIX (2UL << REG_MI_DMA0CNT_DAR_SHIFT) // fix destination address
87 #define MI_DMA_DEST_RELOAD (3UL << REG_MI_DMA0CNT_DAR_SHIFT) // increment destination address and reload
88
89 //---- forwarding size
90 #define MI_DMA_COUNT_MASK (REG_MI_DMA0CNT_WORDCNT_MASK) // mask of forwarding size
91 #define MI_DMA_COUNT_SHIFT (REG_MI_DMA0CNT_WORDCNT_SHIFT) // shift of forwarding size
92
93 //================================================================
94 // for convinience to access NDMA register
95 //================================================================
96 #define MI_DMA_NUM_WOFFSET(ndmaNo) (ndmaNo * 3)
97 #define MI_DMA_REG_SAD_WOFFSET 0
98 #define MI_DMA_REG_DAD_WOFFSET 1
99 #define MI_DMA_REG_CNT_WOFFSET 2
100
101 #define MI_DMA_REGADDR(dmaNo, reg) (((vu32*)REG_DMA0SAD_ADDR) + MI_DMA_NUM_WOFFSET(dmaNo) + (reg) )
102 #define MI_DMA_REG(dmaNo, reg) ( *( MI_DMA_REGADDR(dmaNo, reg) ) )
103
104 //--------------------------------------------------------------------------------
105 // definitions for convenience.
106 //
107 //---- directions and width
108 #define MI_DMA_SINC_DINC_16 ( MI_DMA_SRC_INC | MI_DMA_DEST_INC | MI_DMA_16BIT_BUS )
109 #define MI_DMA_SFIX_DINC_16 ( MI_DMA_SRC_FIX | MI_DMA_DEST_INC | MI_DMA_16BIT_BUS )
110 #define MI_DMA_SINC_DFIX_16 ( MI_DMA_SRC_INC | MI_DMA_DEST_FIX | MI_DMA_16BIT_BUS )
111 #define MI_DMA_SFIX_DFIX_16 ( MI_DMA_SRC_FIX | MI_DMA_DEST_FIX | MI_DMA_16BIT_BUS )
112 #define MI_DMA_SINC_DINC_32 ( MI_DMA_SRC_INC | MI_DMA_DEST_INC | MI_DMA_32BIT_BUS )
113 #define MI_DMA_SFIX_DINC_32 ( MI_DMA_SRC_FIX | MI_DMA_DEST_INC | MI_DMA_32BIT_BUS )
114 #define MI_DMA_SINC_DFIX_32 ( MI_DMA_SRC_INC | MI_DMA_DEST_FIX | MI_DMA_32BIT_BUS )
115 #define MI_DMA_SFIX_DFIX_32 ( MI_DMA_SRC_FIX | MI_DMA_DEST_FIX | MI_DMA_32BIT_BUS )
116
117 #define MI_DMA_IMM16ENABLE ( MI_DMA_ENABLE | MI_DMA_TIMING_IMM | MI_DMA_16BIT_BUS )
118 #define MI_DMA_IMM32ENABLE ( MI_DMA_ENABLE | MI_DMA_TIMING_IMM | MI_DMA_32BIT_BUS )
119 #define MI_DMA_IMM16DISABLE ( MI_DMA_DISABLE | MI_DMA_TIMING_IMM | MI_DMA_16BIT_BUS )
120 #define MI_DMA_IMM32DISABLE ( MI_DMA_DISABLE | MI_DMA_TIMING_IMM | MI_DMA_32BIT_BUS )
121
122 //---- clear
123 #define MI_CNT_CLEAR16(size) ( MI_DMA_IMM16ENABLE | MI_DMA_SRC_FIX | MI_DMA_DEST_INC | ((size)/2) )
124 #define MI_CNT_CLEAR32(size) ( MI_DMA_IMM32ENABLE | MI_DMA_SRC_FIX | MI_DMA_DEST_INC | ((size)/4) )
125 #define MI_CNT_CLEAR16_IF(size) ( MI_CNT_CLEAR16((size)) | MI_DMA_IF_ENABLE )
126 #define MI_CNT_CLEAR32_IF(size) ( MI_CNT_CLEAR32((size)) | MI_DMA_IF_ENABLE )
127
128 #define MI_CNT_SET_CLEAR16(size) ( MI_DMA_IMM16DISABLE | MI_DMA_SRC_FIX | MI_DMA_DEST_INC | ((size)/2) )
129 #define MI_CNT_SET_CLEAR32(size) ( MI_DMA_IMM32DISABLE | MI_DMA_SRC_FIX | MI_DMA_DEST_INC | ((size)/4) )
130 #define MI_CNT_SET_CLEAR16_IF(size)( MI_CNT_SET_CLEAR16((size)) | MI_DMA_IF_ENABLE )
131 #define MI_CNT_SET_CLEAR32_IF(size)( MI_CNT_SET_CLEAR32((size)) | MI_DMA_IF_ENABLE )
132
133 //---- copy
134 #define MI_CNT_COPY16(size) ( MI_DMA_IMM16ENABLE | MI_DMA_SRC_INC | MI_DMA_DEST_INC | ((size)/2) )
135 #define MI_CNT_COPY32(size) ( MI_DMA_IMM32ENABLE | MI_DMA_SRC_INC | MI_DMA_DEST_INC | ((size)/4) )
136 #define MI_CNT_COPY16_IF(size) ( MI_CNT_COPY16((size)) | MI_DMA_IF_ENABLE )
137 #define MI_CNT_COPY32_IF(size) ( MI_CNT_COPY32((size)) | MI_DMA_IF_ENABLE )
138
139 #define MI_CNT_SET_COPY16(size) ( MI_DMA_IMM16DISABLE | MI_DMA_SRC_INC | MI_DMA_DEST_INC | ((size)/2) )
140 #define MI_CNT_SET_COPY32(size) ( MI_DMA_IMM32DISABLE | MI_DMA_SRC_INC | MI_DMA_DEST_INC | ((size)/4) )
141 #define MI_CNT_SET_COPY16_IF(size) ( MI_CNT_SET_COPY16((size)) | MI_DMA_IF_ENABLE )
142 #define MI_CNT_SET_COPY32_IF(size) ( MI_CNT_SET_COPY32((size)) | MI_DMA_IF_ENABLE )
143
144 //---- send
145 #define MI_CNT_SEND16(size) ( MI_DMA_IMM16ENABLE | MI_DMA_SRC_INC | MI_DMA_DEST_FIX | ((size)/2) )
146 #define MI_CNT_SEND32(size) ( MI_DMA_IMM32ENABLE | MI_DMA_SRC_INC | MI_DMA_DEST_FIX | ((size)/4) )
147 #define MI_CNT_SEND16_IF(size) ( MI_CNT_SEND16((size)) | MI_DMA_IF_ENABLE )
148 #define MI_CNT_SEND32_IF(size) ( MI_CNT_SEND32((size)) | MI_DMA_IF_ENABLE )
149
150 #define MI_CNT_SET_SEND16(size) ( MI_DMA_IMM16DISABLE | MI_DMA_SRC_INC | MI_DMA_DEST_FIX | ((size)/2) )
151 #define MI_CNT_SET_SEND32(size) ( MI_DMA_IMM32DISABLE | MI_DMA_SRC_INC | MI_DMA_DEST_FIX | ((size)/4) )
152 #define MI_CNT_SET_SEND16_IF(size) ( MI_CNT_SET_SEND16((size)) | MI_DMA_IF_ENABLE )
153 #define MI_CNT_SET_SEND32_IF(size) ( MI_CNT_SET_SEND32((size)) | MI_DMA_IF_ENABLE )
154
155 //---- recv
156 #define MI_CNT_RECV16(size) ( MI_DMA_IMM16ENABLE | MI_DMA_SRC_FIX | MI_DMA_DEST_INC | ((size)/2) )
157 #define MI_CNT_RECV32(size) ( MI_DMA_IMM32ENABLE | MI_DMA_SRC_FIX | MI_DMA_DEST_INC | ((size)/4) )
158 #define MI_CNT_RECV16_IF(size) ( MI_CNT_RECV16((size)) | MI_DMA_IF_ENABLE )
159 #define MI_CNT_RECV32_IF(size) ( MI_CNT_RECV32((size)) | MI_DMA_IF_ENABLE )
160
161 #define MI_CNT_SET_RECV16(size) ( MI_DMA_IMM16DISABLE | MI_DMA_SRC_FIX | MI_DMA_DEST_INC | ((size)/2) )
162 #define MI_CNT_SET_RECV32(size) ( MI_DMA_IMM32DISABLE | MI_DMA_SRC_FIX | MI_DMA_DEST_INC | ((size)/4) )
163 #define MI_CNT_SET_RECV16_IF(size) ( MI_CNT_SET_RECV16((size)) | MI_DMA_IF_ENABLE )
164 #define MI_CNT_SET_RECV32_IF(size) ( MI_CNT_SET_RECV32((size)) | MI_DMA_IF_ENABLE )
165
166 //---- pipe
167 #define MI_CNT_PIPE16(size) ( MI_DMA_IMM16ENABLE | MI_DMA_SRC_FIX | MI_DMA_DEST_FIX | ((size)/2) )
168 #define MI_CNT_PIPE32(size) ( MI_DMA_IMM32ENABLE | MI_DMA_SRC_FIX | MI_DMA_DEST_FIX | ((size)/4) )
169 #define MI_CNT_PIPE16_IF(size) ( MI_CNT_PIPE16((size)) | MI_DMA_IF_ENABLE )
170 #define MI_CNT_PIPE32_IF(size) ( MI_CNT_PIPE32((size)) | MI_DMA_IF_ENABLE )
171
172 #define MI_CNT_SET_PIPE16(size) ( MI_DMA_IMM16DISABLE | MI_DMA_SRC_FIX | MI_DMA_DEST_FIX | ((size)/2) )
173 #define MI_CNT_SET_PIPE32(size) ( MI_DMA_IMM32DISABLE | MI_DMA_SRC_FIX | MI_DMA_DEST_FIX | ((size)/4) )
174 #define MI_CNT_SET_PIPE16_IF(size) ( MI_CNT_SET_PIPE16((size)) | MI_DMA_IF_ENABLE )
175 #define MI_CNT_SET_PIPE32_IF(size) ( MI_CNT_SET_PIPE32((size)) | MI_DMA_IF_ENABLE )
176
177 //---- HBlank copy (only for ARM9)
178 #ifdef SDK_ARM9
179 # define MI_CNT_HBCOPY16(size) ( MI_DMA_ENABLE | MI_DMA_TIMING_H_BLANK | MI_DMA_SRC_INC | MI_DMA_DEST_RELOAD | MI_DMA_CONTINUOUS_ON | MI_DMA_16BIT_BUS | ((size)/2) )
180 # define MI_CNT_HBCOPY32(size) ( MI_DMA_ENABLE | MI_DMA_TIMING_H_BLANK | MI_DMA_SRC_INC | MI_DMA_DEST_RELOAD | MI_DMA_CONTINUOUS_ON | MI_DMA_32BIT_BUS | ((size)/4) )
181 # define MI_CNT_HBCOPY16_IF(size) ( MI_CNT_HBCOPY16((size)) | MI_DMA_IF_ENABLE )
182 # define MI_CNT_HBCOPY32_IF(size) ( MI_CNT_HBCOPY32((size)) | MI_DMA_IF_ENABLE )
183 #endif // SDK_ARM9
184
185 //---- VBlank copy
186 #define MI_CNT_VBCOPY16(size) ( MI_DMA_ENABLE | MI_DMA_TIMING_V_BLANK | MI_DMA_SRC_INC | MI_DMA_DEST_INC | MI_DMA_16BIT_BUS | ((size)/2) )
187 #define MI_CNT_VBCOPY32(size) ( MI_DMA_ENABLE | MI_DMA_TIMING_V_BLANK | MI_DMA_SRC_INC | MI_DMA_DEST_INC | MI_DMA_32BIT_BUS | ((size)/4) )
188 #define MI_CNT_VBCOPY16_IF(size) ( MI_CNT_VBCOPY16((size)) | MI_DMA_IF_ENABLE )
189 #define MI_CNT_VBCOPY32_IF(size) ( MI_CNT_VBCOPY32((size)) | MI_DMA_IF_ENABLE )
190
191 //---- CARD read
192 // (other settings are not available)
193 #define MI_CNT_CARDRECV32(size) ( MI_DMA_ENABLE | MI_DMA_TIMING_CARD | MI_DMA_SRC_FIX | MI_DMA_DEST_INC | MI_DMA_32BIT_BUS | ((size)/4) )
194
195
196 //---- memory copy (only for ARM9)
197 #ifdef SDK_ARM9
198 # define MI_CNT_MMCOPY(size) ( MI_DMA_ENABLE | MI_DMA_TIMING_DISP_MMEM | MI_DMA_SRC_INC | MI_DMA_DEST_FIX | MI_DMA_CONTINUOUS_ON | MI_DMA_32BIT_BUS | (4) )
199 #endif // SDK_ARM9
200
201 //---- geometry command copy (only for ARM9)
202 #ifdef SDK_ARM9
203 # define MI_CNT_GXCOPY(size) ( MI_DMA_ENABLE | MI_DMA_TIMING_GXFIFO | MI_DMA_SRC_INC | MI_DMA_DEST_FIX | MI_DMA_32BIT_BUS | ((size)/4) )
204 # define MI_CNT_GXCOPY_IF(size) ( MI_CNT_GXCOPY(size) | MI_DMA_IF_ENABLE )
205 #endif // SDK_ARM9
206
207
208 //---- DMA callback
209 typedef void (*MIDmaCallback) (void *);
210
211 //================================================================================
212 // memory operation using DMA (sync)
213 //================================================================================
214 /*---------------------------------------------------------------------------*
215 Name: MI_DmaFill32
216
217 Description: fill memory with specified data.
218 sync 32bit version
219
220 Arguments: dmaNo : DMA channel No.
221 dest : destination address
222 data : fill data
223 size : size (byte)
224
225 Returns: None
226 *---------------------------------------------------------------------------*/
227 void MIi_DmaFill32(u32 dmaNo, void *dest, u32 data, u32 size, BOOL dmaEnable);
MI_DmaFill32(u32 dmaNo,void * dest,u32 data,u32 size)228 static inline void MI_DmaFill32(u32 dmaNo, void *dest, u32 data, u32 size)
229 {
230 MIi_DmaFill32(dmaNo, dest, data, size, TRUE);
231 }
MI_DmaFill32_SetUp(u32 dmaNo,void * dest,u32 data,u32 size)232 static inline void MI_DmaFill32_SetUp(u32 dmaNo, void *dest, u32 data, u32 size)
233 {
234 MIi_DmaFill32(dmaNo, dest, data, size, FALSE);
235 }
236
237 /*---------------------------------------------------------------------------*
238 Name: MI_DmaCopy32
239
240 Description: copy memory with DMA
241 sync 32bit version
242
243 Arguments: dmaNo : DMA channel No.
244 src : source address
245 dest : destination address
246 size : size (byte)
247
248 Returns: None
249 *---------------------------------------------------------------------------*/
250 void MIi_DmaCopy32(u32 dmaNo, const void *src, void *dest, u32 size, BOOL dmaEnable);
MI_DmaCopy32(u32 dmaNo,const void * src,void * dest,u32 size)251 static inline void MI_DmaCopy32(u32 dmaNo, const void *src, void *dest, u32 size)
252 {
253 MIi_DmaCopy32(dmaNo, src, dest, size, TRUE);
254 }
MI_DmaCopy32_SetUp(u32 dmaNo,const void * src,void * dest,u32 size)255 static inline void MI_DmaCopy32_SetUp(u32 dmaNo, const void *src, void *dest, u32 size)
256 {
257 MIi_DmaCopy32(dmaNo, src, dest, size, FALSE);
258 }
259
260 /*---------------------------------------------------------------------------*
261 Name: MI_DmaClear32
262
263 Description: fill memory with 0
264 sync 32bit version
265
266 Arguments: dmaNo : DMA channel No.
267 dest : destination address
268 size : size (byte)
269
270 Returns: None
271 *---------------------------------------------------------------------------*/
MI_DmaClear32(u32 dmaNo,void * dest,u32 size)272 static inline void MI_DmaClear32(u32 dmaNo, void *dest, u32 size)
273 {
274 MIi_DmaFill32(dmaNo, dest, 0, size, TRUE);
275 }
MI_DmaClear32_SetUp(u32 dmaNo,void * dest,u32 size)276 static inline void MI_DmaClear32_SetUp(u32 dmaNo, void *dest, u32 size)
277 {
278 MIi_DmaFill32(dmaNo, dest, 0, size, FALSE);
279 }
280
281 /*---------------------------------------------------------------------------*
282 Name: MI_DmaSend32
283
284 Description: send u32 data to fixed address
285 sync 32bit version
286
287 Arguments: dmaNo : DMA channel No.
288 src : data stream to send
289 dest : destination address. not incremented
290 size : size (byte)
291
292 Returns: None
293 *---------------------------------------------------------------------------*/
294 void MIi_DmaSend32(u32 dmaNo, const void *src, volatile void *dest, u32 size, BOOL dmaEnable);
MI_DmaSend32(u32 dmaNo,const void * src,volatile void * dest,u32 size)295 static inline void MI_DmaSend32(u32 dmaNo, const void *src, volatile void *dest, u32 size)
296 {
297 MIi_DmaSend32(dmaNo, src, dest, size, TRUE);
298 }
MI_DmaSend32_SetUp(u32 dmaNo,const void * src,volatile void * dest,u32 size)299 static inline void MI_DmaSend32_SetUp(u32 dmaNo, const void *src, volatile void *dest, u32 size)
300 {
301 MIi_DmaSend32(dmaNo, src, dest, size, FALSE);
302 }
303
304 /*---------------------------------------------------------------------------*
305 Name: MI_DmaRecv32
306
307 Description: receive u32 data from fixed address
308 sync 32bit version
309
310 Arguments: dmaNo : DMA channel No.
311 src : source address. not incremented
312 dest : data buffer to receive
313 size : size (byte)
314
315 Returns: None
316 *---------------------------------------------------------------------------*/
317 void MIi_DmaRecv32(u32 dmaNo, volatile const void *src, void *dest, u32 size, BOOL dmaEnable);
MI_DmaRecv32(u32 dmaNo,volatile const void * src,void * dest,u32 size)318 static inline void MI_DmaRecv32(u32 dmaNo, volatile const void *src, void *dest, u32 size)
319 {
320 MIi_DmaRecv32(dmaNo, src, dest, size, TRUE);
321 }
MI_DmaRecv32_SetUp(u32 dmaNo,volatile const void * src,void * dest,u32 size)322 static inline void MI_DmaRecv32_SetUp(u32 dmaNo, volatile const void *src, void *dest, u32 size)
323 {
324 MIi_DmaRecv32(dmaNo, src, dest, size, FALSE);
325 }
326
327 /*---------------------------------------------------------------------------*
328 Name: MI_DmaPipe32
329
330 Description: pipe data from fixed address to fixed address.
331 sync 32bit version
332
333 Arguments: dmaNo : DMA channel No.
334 src : source address. not incremented
335 dest : destination address. not incremented
336 size : size (byte)
337
338 Returns: None
339 *---------------------------------------------------------------------------*/
340 void MIi_DmaPipe32(u32 dmaNo, volatile const void *src, volatile void *dest, u32 size, BOOL dmaEnable);
MI_DmaPipe32(u32 dmaNo,volatile const void * src,volatile void * dest,u32 size)341 static inline void MI_DmaPipe32(u32 dmaNo, volatile const void *src, volatile void *dest, u32 size)
342 {
343 MIi_DmaPipe32(dmaNo, src, dest, size, TRUE);
344 }
MI_DmaPipe32_SetUp(u32 dmaNo,volatile const void * src,volatile void * dest,u32 size)345 static inline void MI_DmaPipe32_SetUp(u32 dmaNo, volatile const void *src, volatile void *dest, u32 size)
346 {
347 MIi_DmaPipe32(dmaNo, src, dest, size, FALSE);
348 }
349
350 /*---------------------------------------------------------------------------*
351 Name: MI_DmaFill16
352
353 Description: fill memory with specified data.
354 sync 16bit version
355
356 Arguments: dmaNo : DMA channel No.
357 dest : destination address
358 data : fill data
359 size : size (byte)
360
361 Returns: None
362 *---------------------------------------------------------------------------*/
363 void MIi_DmaFill16(u32 dmaNo, void *dest, u16 data, u32 size, BOOL dmaEnable);
MI_DmaFill16(u32 dmaNo,void * dest,u16 data,u32 size)364 static inline void MI_DmaFill16(u32 dmaNo, void *dest, u16 data, u32 size)
365 {
366 MIi_DmaFill16(dmaNo, dest, data, size, TRUE);
367 }
MI_DmaFill16_SetUp(u32 dmaNo,void * dest,u16 data,u32 size)368 static inline void MI_DmaFill16_SetUp(u32 dmaNo, void *dest, u16 data, u32 size)
369 {
370 MIi_DmaFill16(dmaNo, dest, data, size, FALSE);
371 }
372
373 /*---------------------------------------------------------------------------*
374 Name: MI_DmaCopy16
375
376 Description: copy memory with DMA
377 sync 16bit version
378
379 Arguments: dmaNo : DMA channel No.
380 src : source address
381 dest : destination address
382 size : size (byte)
383
384 Returns: None
385 *---------------------------------------------------------------------------*/
386 void MIi_DmaCopy16(u32 dmaNo, const void *src, void *dest, u32 size, BOOL dmaEnable);
MI_DmaCopy16(u32 dmaNo,const void * src,void * dest,u32 size)387 static inline void MI_DmaCopy16(u32 dmaNo, const void *src, void *dest, u32 size)
388 {
389 MIi_DmaCopy16(dmaNo, src, dest, size, TRUE);
390 }
MI_DmaCopy16_SetUp(u32 dmaNo,const void * src,void * dest,u32 size)391 static inline void MI_DmaCopy16_SetUp(u32 dmaNo, const void *src, void *dest, u32 size)
392 {
393 MIi_DmaCopy16(dmaNo, src, dest, size, FALSE);
394 }
395
396 /*---------------------------------------------------------------------------*
397 Name: MI_DmaClear16
398
399 Description: fill memory with 0
400 sync 16bit version
401
402 Arguments: dmaNo : DMA channel No.
403 dest : destination address
404 size : size (byte)
405
406 Returns: None
407 *---------------------------------------------------------------------------*/
MI_DmaClear16(u32 dmaNo,void * dest,u32 size)408 static inline void MI_DmaClear16(u32 dmaNo, void *dest, u32 size)
409 {
410 MIi_DmaFill16(dmaNo, dest, 0, size, TRUE);
411 }
MI_DmaClear16_SetUp(u32 dmaNo,void * dest,u32 size)412 static inline void MI_DmaClear16_SetUp(u32 dmaNo, void *dest, u32 size)
413 {
414 MIi_DmaFill16(dmaNo, dest, 0, size, FALSE);
415 }
416
417 /*---------------------------------------------------------------------------*
418 Name: MI_DmaSend16
419
420 Description: send u16 data to fixed address
421 sync 16bit version
422
423 Arguments: dmaNo : DMA channel No.
424 src : data stream to send
425 dest : destination address. not incremented
426 size : size (byte)
427
428 Returns: None
429 *---------------------------------------------------------------------------*/
430 void MIi_DmaSend16(u32 dmaNo, const void *src, volatile void *dest, u32 size, BOOL dmaEnable);
MI_DmaSend16(u32 dmaNo,const void * src,volatile void * dest,u32 size)431 static inline void MI_DmaSend16(u32 dmaNo, const void *src, volatile void *dest, u32 size)
432 {
433 MIi_DmaSend16(dmaNo, src, dest, size, TRUE);
434 }
MI_DmaSend16_SetUp(u32 dmaNo,const void * src,volatile void * dest,u32 size)435 static inline void MI_DmaSend16_SetUp(u32 dmaNo, const void *src, volatile void *dest, u32 size)
436 {
437 MIi_DmaSend16(dmaNo, src, dest, size, FALSE);
438 }
439
440 /*---------------------------------------------------------------------------*
441 Name: MI_DmaRecv16
442
443 Description: receive u16 data from fixed address
444 sync 16bit version
445
446 Arguments: dmaNo : DMA channel No.
447 src : source address. not incremented
448 dest : data buffer to receive
449 size : size (byte)
450
451 Returns: None
452 *---------------------------------------------------------------------------*/
453 void MIi_DmaRecv16(u32 dmaNo, volatile const void *src, void *dest, u32 size, BOOL dmaEnable);
MI_DmaRecv16(u32 dmaNo,volatile const void * src,void * dest,u32 size)454 static inline void MI_DmaRecv16(u32 dmaNo, volatile const void *src, void *dest, u32 size)
455 {
456 MIi_DmaRecv16(dmaNo, src, dest, size, TRUE);
457 }
MI_DmaRecv16_SetUp(u32 dmaNo,volatile const void * src,void * dest,u32 size)458 static inline void MI_DmaRecv16_SetUp(u32 dmaNo, volatile const void *src, void *dest, u32 size)
459 {
460 MIi_DmaRecv16(dmaNo, src, dest, size, FALSE);
461 }
462
463 /*---------------------------------------------------------------------------*
464 Name: MI_DmaPipe16
465
466 Description: pipe data from fixed address to fixed address.
467 sync 16bit version
468
469 Arguments: dmaNo : DMA channel No.
470 src : source address. not incremented
471 dest : destination address. not incremented
472 size : size (byte)
473
474 Returns: None
475 *---------------------------------------------------------------------------*/
476 void MIi_DmaPipe16(u32 dmaNo, volatile const void *src, volatile void *dest, u32 size, BOOL dmaEnable);
MI_DmaPipe16(u32 dmaNo,volatile const void * src,volatile void * dest,u32 size)477 static inline void MI_DmaPipe16(u32 dmaNo, volatile const void *src, volatile void *dest, u32 size)
478 {
479 MIi_DmaPipe16(dmaNo, src, dest, size, TRUE);
480 }
MI_DmaPipe16_SetUp(u32 dmaNo,volatile const void * src,volatile void * dest,u32 size)481 static inline void MI_DmaPipe16_SetUp(u32 dmaNo, volatile const void *src, volatile void *dest, u32 size)
482 {
483 MIi_DmaPipe16(dmaNo, src, dest, size, FALSE);
484 }
485
486 //================================================================================
487 // memory operation using DMA (async)
488 //================================================================================
489 /*---------------------------------------------------------------------------*
490 Name: MI_DmaFill32Async
491
492 Description: fill memory with specified data.
493 async 32bit version
494
495 Arguments: dmaNo : DMA channel No.
496 dest : destination address
497 data : fill data
498 size : size (byte)
499 callback : callback function called finish DMA
500 arg : callback argument
501
502 Returns: None
503 *---------------------------------------------------------------------------*/
504 void MIi_DmaFill32Async(u32 dmaNo, void *dest, u32 data, u32 size, MIDmaCallback callback, void *arg, BOOL dmaEnable);
MI_DmaFill32Async(u32 dmaNo,void * dest,u32 data,u32 size,MIDmaCallback callback,void * arg)505 static inline void MI_DmaFill32Async(u32 dmaNo, void *dest, u32 data, u32 size, MIDmaCallback callback, void *arg)
506 {
507 MIi_DmaFill32Async(dmaNo, dest, data, size, callback, arg, TRUE);
508 }
MI_DmaFill32Async_SetUp(u32 dmaNo,void * dest,u32 data,u32 size,MIDmaCallback callback,void * arg)509 static inline void MI_DmaFill32Async_SetUp(u32 dmaNo, void *dest, u32 data, u32 size, MIDmaCallback callback, void *arg)
510 {
511 MIi_DmaFill32Async(dmaNo, dest, data, size, callback, arg, FALSE);
512 }
513
514 /*---------------------------------------------------------------------------*
515 Name: MI_DmaCopy32Async
516
517 Description: copy memory with DMA
518 async 32bit version
519
520 Arguments: dmaNo : DMA channel No.
521 src : source address
522 dest : destination address
523 size : size (byte)
524 callback : callback function called finish DMA
525 arg : callback argument
526
527 Returns: None
528 *---------------------------------------------------------------------------*/
529 void MIi_DmaCopy32Async(u32 dmaNo, const void *src, void *dest, u32 size, MIDmaCallback callback, void *arg, BOOL dmaEnable);
MI_DmaCopy32Async(u32 dmaNo,const void * src,void * dest,u32 size,MIDmaCallback callback,void * arg)530 static inline void MI_DmaCopy32Async(u32 dmaNo, const void *src, void *dest, u32 size, MIDmaCallback callback, void *arg)
531 {
532 MIi_DmaCopy32Async(dmaNo, src, dest, size, callback, arg, TRUE);
533 }
MI_DmaCopy32Async_SetUp(u32 dmaNo,const void * src,void * dest,u32 size,MIDmaCallback callback,void * arg)534 static inline void MI_DmaCopy32Async_SetUp(u32 dmaNo, const void *src, void *dest, u32 size, MIDmaCallback callback, void *arg)
535 {
536 MIi_DmaCopy32Async(dmaNo, src, dest, size, callback, arg, FALSE);
537 }
538
539 /*---------------------------------------------------------------------------*
540 Name: MI_DmaClear32Async
541
542 Description: fill memory with 0
543 async 32bit version
544
545 Arguments: dmaNo : DMA channel No.
546 dest : destination address
547 size : size (byte)
548 callback : callback function called finish DMA
549 arg : callback argument
550
551 Returns: None
552 *---------------------------------------------------------------------------*/
MI_DmaClear32Async(u32 dmaNo,void * dest,u32 size,MIDmaCallback callback,void * arg)553 static inline void MI_DmaClear32Async(u32 dmaNo, void *dest, u32 size, MIDmaCallback callback, void *arg)
554 {
555 MIi_DmaFill32Async(dmaNo, dest, 0, size, callback, arg, TRUE);
556 }
MI_DmaClear32Async_SetUp(u32 dmaNo,void * dest,u32 size,MIDmaCallback callback,void * arg)557 static inline void MI_DmaClear32Async_SetUp(u32 dmaNo, void *dest, u32 size, MIDmaCallback callback, void *arg)
558 {
559 MIi_DmaFill32Async(dmaNo, dest, 0, size, callback, arg, FALSE);
560 }
561
562 /*---------------------------------------------------------------------------*
563 Name: MI_DmaSend32Async
564
565 Description: send u32 data to fixed address
566 async 32bit version
567
568 Arguments: dmaNo : DMA channel No.
569 src : data stream to send
570 dest : destination address. not incremented
571 size : size (byte)
572 callback : callback function called finish DMA
573 arg : callback argument
574
575 Returns: None
576 *---------------------------------------------------------------------------*/
577 void MIi_DmaSend32Async(u32 dmaNo, const void *src, volatile void *dest, u32 size, MIDmaCallback callback, void *arg, BOOL dmaEnable);
MI_DmaSend32Async(u32 dmaNo,const void * src,volatile void * dest,u32 size,MIDmaCallback callback,void * arg)578 static inline void MI_DmaSend32Async(u32 dmaNo, const void *src, volatile void *dest, u32 size, MIDmaCallback callback, void *arg)
579 {
580 MIi_DmaSend32Async(dmaNo, src, dest, size, callback, arg, TRUE);
581 }
MI_DmaSend32Async_SetUp(u32 dmaNo,const void * src,volatile void * dest,u32 size,MIDmaCallback callback,void * arg)582 static inline void MI_DmaSend32Async_SetUp(u32 dmaNo, const void *src, volatile void *dest, u32 size, MIDmaCallback callback, void *arg)
583 {
584 MIi_DmaSend32Async(dmaNo, src, dest, size, callback, arg, FALSE);
585 }
586
587 /*---------------------------------------------------------------------------*
588 Name: MI_DmaRecv32Async
589
590 Description: receive u32 data from fixed address
591 async 32bit version
592
593 Arguments: dmaNo : DMA channel No.
594 src : source address. not incremented
595 dest : data buffer to receive
596 size : size (byte)
597 callback : callback function called finish DMA
598 arg : callback argument
599
600 Returns: None
601 *---------------------------------------------------------------------------*/
602 void MIi_DmaRecv32Async(u32 dmaNo, volatile const void *src, void *dest, u32 size, MIDmaCallback callback, void *arg, BOOL dmaEnable);
MI_DmaRecv32Async(u32 dmaNo,volatile const void * src,void * dest,u32 size,MIDmaCallback callback,void * arg)603 static inline void MI_DmaRecv32Async(u32 dmaNo, volatile const void *src, void *dest, u32 size, MIDmaCallback callback, void *arg)
604 {
605 MIi_DmaRecv32Async(dmaNo, src, dest, size, callback, arg, TRUE);
606 }
MI_DmaRecv32Async_SetUp(u32 dmaNo,volatile const void * src,void * dest,u32 size,MIDmaCallback callback,void * arg)607 static inline void MI_DmaRecv32Async_SetUp(u32 dmaNo, volatile const void *src, void *dest, u32 size, MIDmaCallback callback, void *arg)
608 {
609 MIi_DmaRecv32Async(dmaNo, src, dest, size, callback, arg, FALSE);
610 }
611
612 /*---------------------------------------------------------------------------*
613 Name: MI_DmaPipe32Async
614
615 Description: pipe data from fixed address to fixed address.
616 async 32bit version
617
618 Arguments: dmaNo : DMA channel No.
619 src : source address. not incremented
620 dest : destination address. not incremented
621 size : size (byte)
622 callback : callback function called finish DMA
623 arg : callback argument
624
625 Returns: None
626 *---------------------------------------------------------------------------*/
627 void MIi_DmaPipe32Async(u32 dmaNo, volatile const void *src, volatile void *dest, u32 size, MIDmaCallback callback, void *arg, BOOL dmaEnable);
MI_DmaPipe32Async(u32 dmaNo,volatile const void * src,volatile void * dest,u32 size,MIDmaCallback callback,void * arg)628 static inline void MI_DmaPipe32Async(u32 dmaNo, volatile const void *src, volatile void *dest, u32 size, MIDmaCallback callback, void *arg)
629 {
630 MIi_DmaPipe32Async(dmaNo, src, dest, size, callback, arg, TRUE);
631 }
MI_DmaPipe32Async_SetUp(u32 dmaNo,volatile const void * src,volatile void * dest,u32 size,MIDmaCallback callback,void * arg)632 static inline void MI_DmaPipe32Async_SetUp(u32 dmaNo, volatile const void *src, volatile void *dest, u32 size, MIDmaCallback callback, void *arg)
633 {
634 MIi_DmaPipe32Async(dmaNo, src, dest, size, callback, arg, FALSE);
635 }
636
637 /*---------------------------------------------------------------------------*
638 Name: MI_DmaFill16Async
639
640 Description: fill memory with specified data.
641 async 16bit version
642
643 Arguments: dmaNo : DMA channel No.
644 dest : destination address
645 data : fill data
646 size : size (byte)
647 callback : callback function called finish DMA
648 arg : callback argument
649
650 Returns: None
651 *---------------------------------------------------------------------------*/
652 void MIi_DmaFill16Async(u32 dmaNo, void *dest, u16 data, u32 size, MIDmaCallback callback, void *arg, BOOL dmaEnable);
MI_DmaFill16Async(u32 dmaNo,void * dest,u16 data,u32 size,MIDmaCallback callback,void * arg)653 static inline void MI_DmaFill16Async(u32 dmaNo, void *dest, u16 data, u32 size, MIDmaCallback callback, void *arg)
654 {
655 MIi_DmaFill16Async(dmaNo, dest, data, size, callback, arg, TRUE);
656 }
MI_DmaFill16Async_SetUp(u32 dmaNo,void * dest,u16 data,u32 size,MIDmaCallback callback,void * arg)657 static inline void MI_DmaFill16Async_SetUp(u32 dmaNo, void *dest, u16 data, u32 size, MIDmaCallback callback, void *arg)
658 {
659 MIi_DmaFill16Async(dmaNo, dest, data, size, callback, arg, FALSE);
660 }
661
662 /*---------------------------------------------------------------------------*
663 Name: MI_DmaCopy16Async
664
665 Description: copy memory with DMA
666 async 16bit version
667
668 Arguments: dmaNo : DMA channel No.
669 src : source address
670 dest : destination address
671 size : size (byte)
672 callback : callback function called finish DMA
673 arg : callback argument
674
675 Returns: None
676 *---------------------------------------------------------------------------*/
677 void MIi_DmaCopy16Async(u32 dmaNo, const void *src, void *dest, u32 size, MIDmaCallback callback, void *arg, BOOL dmaEnable);
MI_DmaCopy16Async(u32 dmaNo,const void * src,void * dest,u32 size,MIDmaCallback callback,void * arg)678 static inline void MI_DmaCopy16Async(u32 dmaNo, const void *src, void *dest, u32 size, MIDmaCallback callback, void *arg)
679 {
680 MIi_DmaCopy16Async(dmaNo, src, dest, size, callback, arg, TRUE);
681 }
MI_DmaCopy16Async_SetUp(u32 dmaNo,const void * src,void * dest,u32 size,MIDmaCallback callback,void * arg)682 static inline void MI_DmaCopy16Async_SetUp(u32 dmaNo, const void *src, void *dest, u32 size, MIDmaCallback callback, void *arg)
683 {
684 MIi_DmaCopy16Async(dmaNo, src, dest, size, callback, arg, FALSE);
685 }
686
687 /*---------------------------------------------------------------------------*
688 Name: MI_DmaClear16Async
689
690 Description: fill memory with 0
691 async 16bit version
692
693 Arguments: dmaNo : DMA channel No.
694 dest : destination address
695 size : size (byte)
696 callback : callback function called finish DMA
697 arg : callback argument
698
699 Returns: None
700 *---------------------------------------------------------------------------*/
MI_DmaClear16Async(u32 dmaNo,void * dest,u32 size,MIDmaCallback callback,void * arg)701 static inline void MI_DmaClear16Async(u32 dmaNo, void *dest, u32 size, MIDmaCallback callback,
702 void *arg)
703 {
704 MIi_DmaFill16Async(dmaNo, dest, 0, size, callback, arg, TRUE);
705 }
MI_DmaClear16Async_SetUp(u32 dmaNo,void * dest,u32 size,MIDmaCallback callback,void * arg)706 static inline void MI_DmaClear16Async_SetUp(u32 dmaNo, void *dest, u32 size, MIDmaCallback callback,
707 void *arg)
708 {
709 MIi_DmaFill16Async(dmaNo, dest, 0, size, callback, arg, FALSE);
710 }
711
712 /*---------------------------------------------------------------------------*
713 Name: MI_DmaSend16Async
714
715 Description: send u16 data to fixed address
716 async 16bit version
717
718 Arguments: dmaNo : DMA channel No.
719 src : data stream to send
720 dest : destination address. not incremented
721 size : size (byte)
722 callback : callback function called finish DMA
723 arg : callback argument
724
725 Returns: None
726 *---------------------------------------------------------------------------*/
727 void MIi_DmaSend16Async(u32 dmaNo, const void *src, volatile void *dest, u32 size, MIDmaCallback callback, void *arg, BOOL dmaEnable);
MI_DmaSend16Async(u32 dmaNo,const void * src,volatile void * dest,u32 size,MIDmaCallback callback,void * arg)728 static inline void MI_DmaSend16Async(u32 dmaNo, const void *src, volatile void *dest, u32 size, MIDmaCallback callback, void *arg)
729 {
730 MIi_DmaSend16Async(dmaNo, src, dest, size, callback, arg, TRUE);
731 }
MI_DmaSend16Async_SetUp(u32 dmaNo,const void * src,volatile void * dest,u32 size,MIDmaCallback callback,void * arg)732 static inline void MI_DmaSend16Async_SetUp(u32 dmaNo, const void *src, volatile void *dest, u32 size, MIDmaCallback callback, void *arg)
733 {
734 MIi_DmaSend16Async(dmaNo, src, dest, size, callback, arg, FALSE);
735 }
736
737 /*---------------------------------------------------------------------------*
738 Name: MI_DmaRecv16Async
739
740 Description: receive u16 data from fixed address
741 async 16bit version
742
743 Arguments: dmaNo : DMA channel No.
744 src : source address. not incremented
745 dest : data buffer to receive
746 size : size (byte)
747 callback : callback function called finish DMA
748 arg : callback argument
749
750 Returns: None
751 *---------------------------------------------------------------------------*/
752 void MIi_DmaRecv16Async(u32 dmaNo, volatile const void *src, void *dest, u32 size, MIDmaCallback callback, void *arg, BOOL dmaEnable);
MI_DmaRecv16Async(u32 dmaNo,volatile const void * src,void * dest,u32 size,MIDmaCallback callback,void * arg)753 static inline void MI_DmaRecv16Async(u32 dmaNo, volatile const void *src, void *dest, u32 size, MIDmaCallback callback, void *arg)
754 {
755 MIi_DmaRecv16Async(dmaNo, src, dest, size, callback, arg, TRUE);
756 }
MI_DmaRecv16Async_SetUp(u32 dmaNo,volatile const void * src,void * dest,u32 size,MIDmaCallback callback,void * arg)757 static inline void MI_DmaRecv16Async_SetUp(u32 dmaNo, volatile const void *src, void *dest, u32 size, MIDmaCallback callback, void *arg)
758 {
759 MIi_DmaRecv16Async(dmaNo, src, dest, size, callback, arg, FALSE);
760 }
761
762 /*---------------------------------------------------------------------------*
763 Name: MI_DmaPipe16Async
764
765 Description: receive u16 data from fixed address
766 async 16bit version
767
768 Arguments: dmaNo : DMA channel No.
769 src : source address. not incremented
770 dest : destination address. not incremented
771 size : size (byte)
772 callback : callback function called finish DMA
773 arg : callback argument
774
775 Returns: None
776 *---------------------------------------------------------------------------*/
777 void MIi_DmaPipe16Async(u32 dmaNo, volatile const void *src, volatile void *dest, u32 size, MIDmaCallback callback, void *arg, BOOL dmaEnable);
MI_DmaPipe16Async(u32 dmaNo,volatile const void * src,volatile void * dest,u32 size,MIDmaCallback callback,void * arg)778 static inline void MI_DmaPipe16Async(u32 dmaNo, volatile const void *src, volatile void *dest, u32 size, MIDmaCallback callback, void *arg)
779 {
780 MIi_DmaPipe16Async(dmaNo, src, dest, size, callback, arg, TRUE);
781 }
MI_DmaPipe16Async_SetUp(u32 dmaNo,volatile const void * src,volatile void * dest,u32 size,MIDmaCallback callback,void * arg)782 static inline void MI_DmaPipe16Async_SetUp(u32 dmaNo, volatile const void *src, volatile void *dest, u32 size, MIDmaCallback callback, void *arg)
783 {
784 MIi_DmaPipe16Async(dmaNo, src, dest, size, callback, arg, FALSE);
785 }
786
787 //================================================================================
788 // HBlank DMA
789 //================================================================================
790 // 32bit
791 void MI_HBlankDmaCopy32(u32 dmaNo, const void *src, void *dest, u32 size);
792 // 16bit
793 void MI_HBlankDmaCopy16(u32 dmaNo, const void *src, void *dest, u32 size);
794 // 32bit, with interrupt when finish DMA
795 void MI_HBlankDmaCopy32If(u32 dmaNo, const void *src, void *dest, u32 size);
796 // 16bit, with interrupt when finish DMA
797 void MI_HBlankDmaCopy16If(u32 dmaNo, const void *src, void *dest, u32 size);
798
799 //================================================================================
800 // VBlank DMA
801 //================================================================================
802 // 32bit sync
803 void MI_VBlankDmaCopy32(u32 dmaNo, const void *src, void *dest, u32 size);
804 // 16bit sync
805 void MI_VBlankDmaCopy16(u32 dmaNo, const void *src, void *dest, u32 size);
806 // 32bit async
807 void MI_VBlankDmaCopy32Async(u32 dmaNo, const void *src, void *dest, u32 size,
808 MIDmaCallback callback, void *arg);
809 // 16bit async
810 void MI_VBlankDmaCopy16Async(u32 dmaNo, const void *src, void *dest, u32 size,
811 MIDmaCallback callback, void *arg);
812
813 //================================================================================
814 // CARD DMA
815 //================================================================================
816 // 32bit sync (CARD-DMA can not use DMA-callback because of continuous-mode)
817 void MIi_CardDmaCopy32(u32 dmaNo, const void *src, void *dest, u32 size);
818
819 //================================================================================
820 // main memory display DMA
821 //================================================================================
822 // (Sync)
823 void MI_DispMemDmaCopy(u32 dmaNo, const void *src);
824
825 //================================================================================
826 // geometry FIFO DMA
827 //================================================================================
828 // 32bit version only.
829 // size unit is byte, equal to 'the amount of commands * 4'
830 // (Sync)
831 void MI_SendGXCommand(u32 dmaNo, const void *src, u32 commandLength);
832 // (Async, in flagment)
833 void MI_SendGXCommandAsync(u32 dmaNo, const void *src, u32 commandLength, MIDmaCallback callback,
834 void *arg);
835 // (Sync, at once)
836 void MI_SendGXCommandFast(u32 dmaNo, const void *src, u32 commandLength);
837 // (Async, at once)
838 void MI_SendGXCommandAsyncFast(u32 dmaNo, const void *src, u32 commandLength,
839 MIDmaCallback callback, void *arg);
840
841 //================================================================================
842 // DMA WAIT
843 //================================================================================
844 /*---------------------------------------------------------------------------*
845 Name: MI_IsDmaBusy
846
847 Description: check whether DMA is busy or not
848
849 Arguments: dmaNo : DMA channel No.
850
851 Returns: TRUE if DMA is busy, FALSE if not
852 *---------------------------------------------------------------------------*/
853 BOOL MI_IsDmaBusy(u32 dmaNo);
854
855 /*---------------------------------------------------------------------------*
856 Name: MI_WaitDma
857
858 Description: wait while DMA is busy
859
860 Arguments: dmaNo : DMA channel No.
861
862 Returns: None
863 *---------------------------------------------------------------------------*/
864 void MI_WaitDma(u32 dmaNo);
865
866 /*---------------------------------------------------------------------------*
867 Name: MI_StopDma
868
869 Description: stop DMA
870
871 Arguments: dmaNo : DMA channel No.
872
873 Returns: None
874 *---------------------------------------------------------------------------*/
875 void MI_StopDma(u32 dmaNo);
876
877 /*---------------------------------------------------------------------------*
878 Name: MI_StopAllDma
879
880 Description: stop all DMA
881
882 Arguments: None
883
884 Returns: None
885 *---------------------------------------------------------------------------*/
886 void MI_StopAllDma(void);
887
888 //================================================================================
889 // restart DMA
890 //================================================================================
891 /*---------------------------------------------------------------------------*
892 Name: MI_DmaRestart
893
894 Description: restart DMA
895 Just set the enable bit.
896
897 Arguments: ndmaNo : DMA channel MI_NDMA_REG( ndmaNo, MI_NDMA_REG_CNT_WOFFSET ) |= MI_DMA_ENABLE;
898 No.
899
900 Returns: None
901 *---------------------------------------------------------------------------*/
902 void MI_DmaRestart(u32 dmaNo);
903
904
905 //================================================================================
906 // setting each register directly (internal)
907 //================================================================================
908 void MIi_SetDmaSrc16( u32 dmaNo, void *src );
909 void MIi_SetDmaSrc32( u32 dmaNo, void *src );
910 void MIi_SetDmaDest16( u32 dmaNo, void *dest );
911 void MIi_SetDmaDest32( u32 dmaNo, void *dest );
912 void MIi_SetDmaSize16( u32 dmaNo, u32 size );
913 void MIi_SetDmaSize32( u32 dmaNo, u32 size );
914
915 //--------------------------------------------------------------------------------
916 #ifdef __cplusplus
917 } /* extern "C" */
918 #endif
919
920 /* NITRO_MI_DMA_H_ */
921 #endif
922