aboutsummaryrefslogtreecommitdiffstats
path: root/arch/arm/mach-bcmring/include/mach/dma.h
diff options
context:
space:
mode:
Diffstat (limited to 'arch/arm/mach-bcmring/include/mach/dma.h')
-rw-r--r--arch/arm/mach-bcmring/include/mach/dma.h630
1 files changed, 0 insertions, 630 deletions
diff --git a/arch/arm/mach-bcmring/include/mach/dma.h b/arch/arm/mach-bcmring/include/mach/dma.h
deleted file mode 100644
index 13e01384d6fc..000000000000
--- a/arch/arm/mach-bcmring/include/mach/dma.h
+++ /dev/null
@@ -1,630 +0,0 @@
1/*****************************************************************************
2* Copyright 2004 - 2008 Broadcom Corporation. All rights reserved.
3*
4* Unless you and Broadcom execute a separate written software license
5* agreement governing use of this software, this software is licensed to you
6* under the terms of the GNU General Public License version 2, available at
7* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
8*
9* Notwithstanding the above, under no circumstances may you combine this
10* software in any way with any other Broadcom software provided under a
11* license other than the GPL, without Broadcom's express prior written
12* consent.
13*****************************************************************************/
14
15/****************************************************************************/
16/**
17* @file dma.h
18*
19* @brief API definitions for the linux DMA interface.
20*/
21/****************************************************************************/
22
23#if !defined(ASM_ARM_ARCH_BCMRING_DMA_H)
24#define ASM_ARM_ARCH_BCMRING_DMA_H
25
26/* ---- Include Files ---------------------------------------------------- */
27
28#include <linux/kernel.h>
29#include <linux/semaphore.h>
30#include <mach/csp/dmacHw.h>
31#include <mach/timer.h>
32
33/* ---- Constants and Types ---------------------------------------------- */
34
35/* If DMA_DEBUG_TRACK_RESERVATION is set to a non-zero value, then the filename */
36/* and line number of the reservation request will be recorded in the channel table */
37
38#define DMA_DEBUG_TRACK_RESERVATION 1
39
40#define DMA_NUM_CONTROLLERS 2
41#define DMA_NUM_CHANNELS 8 /* per controller */
42
43typedef enum {
44 DMA_DEVICE_MEM_TO_MEM, /* For memory to memory transfers */
45 DMA_DEVICE_I2S0_DEV_TO_MEM,
46 DMA_DEVICE_I2S0_MEM_TO_DEV,
47 DMA_DEVICE_I2S1_DEV_TO_MEM,
48 DMA_DEVICE_I2S1_MEM_TO_DEV,
49 DMA_DEVICE_APM_CODEC_A_DEV_TO_MEM,
50 DMA_DEVICE_APM_CODEC_A_MEM_TO_DEV,
51 DMA_DEVICE_APM_CODEC_B_DEV_TO_MEM,
52 DMA_DEVICE_APM_CODEC_B_MEM_TO_DEV,
53 DMA_DEVICE_APM_CODEC_C_DEV_TO_MEM, /* Additional mic input for beam-forming */
54 DMA_DEVICE_APM_PCM0_DEV_TO_MEM,
55 DMA_DEVICE_APM_PCM0_MEM_TO_DEV,
56 DMA_DEVICE_APM_PCM1_DEV_TO_MEM,
57 DMA_DEVICE_APM_PCM1_MEM_TO_DEV,
58 DMA_DEVICE_SPUM_DEV_TO_MEM,
59 DMA_DEVICE_SPUM_MEM_TO_DEV,
60 DMA_DEVICE_SPIH_DEV_TO_MEM,
61 DMA_DEVICE_SPIH_MEM_TO_DEV,
62 DMA_DEVICE_UART_A_DEV_TO_MEM,
63 DMA_DEVICE_UART_A_MEM_TO_DEV,
64 DMA_DEVICE_UART_B_DEV_TO_MEM,
65 DMA_DEVICE_UART_B_MEM_TO_DEV,
66 DMA_DEVICE_PIF_MEM_TO_DEV,
67 DMA_DEVICE_PIF_DEV_TO_MEM,
68 DMA_DEVICE_ESW_DEV_TO_MEM,
69 DMA_DEVICE_ESW_MEM_TO_DEV,
70 DMA_DEVICE_VPM_MEM_TO_MEM,
71 DMA_DEVICE_CLCD_MEM_TO_MEM,
72 DMA_DEVICE_NAND_MEM_TO_MEM,
73 DMA_DEVICE_MEM_TO_VRAM,
74 DMA_DEVICE_VRAM_TO_MEM,
75
76 /* Add new entries before this line. */
77
78 DMA_NUM_DEVICE_ENTRIES,
79 DMA_DEVICE_NONE = 0xff, /* Special value to indicate that no device is currently assigned. */
80
81} DMA_Device_t;
82
83/****************************************************************************
84*
85* The DMA_Handle_t is the primary object used by callers of the API.
86*
87*****************************************************************************/
88
89#define DMA_INVALID_HANDLE ((DMA_Handle_t) -1)
90
91typedef int DMA_Handle_t;
92
93/****************************************************************************
94*
95* The DMA_DescriptorRing_t contains a ring of descriptors which is used
96* to point to regions of memory.
97*
98*****************************************************************************/
99
100typedef struct {
101 void *virtAddr; /* Virtual Address of the descriptor ring */
102 dma_addr_t physAddr; /* Physical address of the descriptor ring */
103 int descriptorsAllocated; /* Number of descriptors allocated in the descriptor ring */
104 size_t bytesAllocated; /* Number of bytes allocated in the descriptor ring */
105
106} DMA_DescriptorRing_t;
107
108/****************************************************************************
109*
110* The DMA_DeviceAttribute_t contains information which describes a
111* particular DMA device (or peripheral).
112*
113* It is anticipated that the arrary of DMA_DeviceAttribute_t's will be
114* statically initialized.
115*
116*****************************************************************************/
117
118/* The device handler is called whenever a DMA operation completes. The reaon */
119/* for it to be called will be a bitmask with one or more of the following bits */
120/* set. */
121
122#define DMA_HANDLER_REASON_BLOCK_COMPLETE dmacHw_INTERRUPT_STATUS_BLOCK
123#define DMA_HANDLER_REASON_TRANSFER_COMPLETE dmacHw_INTERRUPT_STATUS_TRANS
124#define DMA_HANDLER_REASON_ERROR dmacHw_INTERRUPT_STATUS_ERROR
125
126typedef void (*DMA_DeviceHandler_t) (DMA_Device_t dev, int reason,
127 void *userData);
128
129#define DMA_DEVICE_FLAG_ON_DMA0 0x00000001
130#define DMA_DEVICE_FLAG_ON_DMA1 0x00000002
131#define DMA_DEVICE_FLAG_PORT_PER_DMAC 0x00000004 /* If set, it means that the port used on DMAC0 is different from the port used on DMAC1 */
132#define DMA_DEVICE_FLAG_ALLOC_DMA1_FIRST 0x00000008 /* If set, allocate from DMA1 before allocating from DMA0 */
133#define DMA_DEVICE_FLAG_IS_DEDICATED 0x00000100
134#define DMA_DEVICE_FLAG_NO_ISR 0x00000200
135#define DMA_DEVICE_FLAG_ALLOW_LARGE_FIFO 0x00000400
136#define DMA_DEVICE_FLAG_IN_USE 0x00000800 /* If set, device is in use on a channel */
137
138/* Note: Some DMA devices can be used from multiple DMA Controllers. The bitmask is used to */
139/* determine which DMA controllers a given device can be used from, and the interface */
140/* array determeines the actual interface number to use for a given controller. */
141
142typedef struct {
143 uint32_t flags; /* Bitmask of DMA_DEVICE_FLAG_xxx constants */
144 uint8_t dedicatedController; /* Controller number to use if DMA_DEVICE_FLAG_IS_DEDICATED is set. */
145 uint8_t dedicatedChannel; /* Channel number to use if DMA_DEVICE_FLAG_IS_DEDICATED is set. */
146 const char *name; /* Will show up in the /proc entry */
147
148 uint32_t dmacPort[DMA_NUM_CONTROLLERS]; /* Specifies the port number when DMA_DEVICE_FLAG_PORT_PER_DMAC flag is set */
149
150 dmacHw_CONFIG_t config; /* Configuration to use when DMA'ing using this device */
151
152 void *userData; /* Passed to the devHandler */
153 DMA_DeviceHandler_t devHandler; /* Called when DMA operations finish. */
154
155 timer_tick_count_t transferStartTime; /* Time the current transfer was started */
156
157 /* The following statistical information will be collected and presented in a proc entry. */
158 /* Note: With a contiuous bandwidth of 1 Gb/sec, it would take 584 years to overflow */
159 /* a 64 bit counter. */
160
161 uint64_t numTransfers; /* Number of DMA transfers performed */
162 uint64_t transferTicks; /* Total time spent doing DMA transfers (measured in timer_tick_count_t's) */
163 uint64_t transferBytes; /* Total bytes transferred */
164 uint32_t timesBlocked; /* Number of times a channel was unavailable */
165 uint32_t numBytes; /* Last transfer size */
166
167 /* It's not possible to free memory which is allocated for the descriptors from within */
168 /* the ISR. So make the presumption that a given device will tend to use the */
169 /* same sized buffers over and over again, and we keep them around. */
170
171 DMA_DescriptorRing_t ring; /* Ring of descriptors allocated for this device */
172
173 /* We stash away some of the information from the previous transfer. If back-to-back */
174 /* transfers are performed from the same buffer, then we don't have to keep re-initializing */
175 /* the descriptor buffers. */
176
177 uint32_t prevNumBytes;
178 dma_addr_t prevSrcData;
179 dma_addr_t prevDstData;
180
181} DMA_DeviceAttribute_t;
182
183/****************************************************************************
184*
185* DMA_Channel_t, DMA_Controller_t, and DMA_State_t are really internal
186* data structures and don't belong in this header file, but are included
187* merely for discussion.
188*
189* By the time this is implemented, these structures will be moved out into
190* the appropriate C source file instead.
191*
192*****************************************************************************/
193
194/****************************************************************************
195*
196* The DMA_Channel_t contains state information about each DMA channel. Some
197* of the channels are dedicated. Non-dedicated channels are shared
198* amongst the other devices.
199*
200*****************************************************************************/
201
202#define DMA_CHANNEL_FLAG_IN_USE 0x00000001
203#define DMA_CHANNEL_FLAG_IS_DEDICATED 0x00000002
204#define DMA_CHANNEL_FLAG_NO_ISR 0x00000004
205#define DMA_CHANNEL_FLAG_LARGE_FIFO 0x00000008
206
207typedef struct {
208 uint32_t flags; /* bitmask of DMA_CHANNEL_FLAG_xxx constants */
209 DMA_Device_t devType; /* Device this channel is currently reserved for */
210 DMA_Device_t lastDevType; /* Device type that used this previously */
211 char name[20]; /* Name passed onto request_irq */
212
213#if (DMA_DEBUG_TRACK_RESERVATION)
214 const char *fileName; /* Place where channel reservation took place */
215 int lineNum; /* Place where channel reservation took place */
216#endif
217 dmacHw_HANDLE_t dmacHwHandle; /* low level channel handle. */
218
219} DMA_Channel_t;
220
221/****************************************************************************
222*
223* The DMA_Controller_t contains state information about each DMA controller.
224*
225* The freeChannelQ is stored in the controller data structure rather than
226* the channel data structure since several of the devices are accessible
227* from multiple controllers, and there is no way to know which controller
228* will become available first.
229*
230*****************************************************************************/
231
232typedef struct {
233 DMA_Channel_t channel[DMA_NUM_CHANNELS];
234
235} DMA_Controller_t;
236
237/****************************************************************************
238*
239* The DMA_Global_t contains all of the global state information used by
240* the DMA code.
241*
242* Callers which need to allocate a shared channel will be queued up
243* on the freeChannelQ until a channel becomes available.
244*
245*****************************************************************************/
246
247typedef struct {
248 struct semaphore lock; /* acquired when manipulating table entries */
249 wait_queue_head_t freeChannelQ;
250
251 DMA_Controller_t controller[DMA_NUM_CONTROLLERS];
252
253} DMA_Global_t;
254
255/* ---- Variable Externs ------------------------------------------------- */
256
257extern DMA_DeviceAttribute_t DMA_gDeviceAttribute[DMA_NUM_DEVICE_ENTRIES];
258
259/* ---- Function Prototypes ---------------------------------------------- */
260
261#if defined(__KERNEL__)
262
263/****************************************************************************/
264/**
265* Initializes the DMA module.
266*
267* @return
268* 0 - Success
269* < 0 - Error
270*/
271/****************************************************************************/
272
273int dma_init(void);
274
275#if (DMA_DEBUG_TRACK_RESERVATION)
276DMA_Handle_t dma_request_channel_dbg(DMA_Device_t dev, const char *fileName,
277 int lineNum);
278#define dma_request_channel(dev) dma_request_channel_dbg(dev, __FILE__, __LINE__)
279#else
280
281/****************************************************************************/
282/**
283* Reserves a channel for use with @a dev. If the device is setup to use
284* a shared channel, then this function will block until a free channel
285* becomes available.
286*
287* @return
288* >= 0 - A valid DMA Handle.
289* -EBUSY - Device is currently being used.
290* -ENODEV - Device handed in is invalid.
291*/
292/****************************************************************************/
293
294DMA_Handle_t dma_request_channel(DMA_Device_t dev /* Device to use with the allocated channel. */
295 );
296#endif
297
298/****************************************************************************/
299/**
300* Frees a previously allocated DMA Handle.
301*
302* @return
303* 0 - DMA Handle was released successfully.
304* -EINVAL - Invalid DMA handle
305*/
306/****************************************************************************/
307
308int dma_free_channel(DMA_Handle_t channel /* DMA handle. */
309 );
310
311/****************************************************************************/
312/**
313* Determines if a given device has been configured as using a shared
314* channel.
315*
316* @return boolean
317* 0 Device uses a dedicated channel
318* non-zero Device uses a shared channel
319*/
320/****************************************************************************/
321
322int dma_device_is_channel_shared(DMA_Device_t dev /* Device to check. */
323 );
324
325/****************************************************************************/
326/**
327* Allocates memory to hold a descriptor ring. The descriptor ring then
328* needs to be populated by making one or more calls to
329* dna_add_descriptors.
330*
331* The returned descriptor ring will be automatically initialized.
332*
333* @return
334* 0 Descriptor ring was allocated successfully
335* -ENOMEM Unable to allocate memory for the desired number of descriptors.
336*/
337/****************************************************************************/
338
339int dma_alloc_descriptor_ring(DMA_DescriptorRing_t *ring, /* Descriptor ring to populate */
340 int numDescriptors /* Number of descriptors that need to be allocated. */
341 );
342
343/****************************************************************************/
344/**
345* Releases the memory which was previously allocated for a descriptor ring.
346*/
347/****************************************************************************/
348
349void dma_free_descriptor_ring(DMA_DescriptorRing_t *ring /* Descriptor to release */
350 );
351
352/****************************************************************************/
353/**
354* Initializes a descriptor ring, so that descriptors can be added to it.
355* Once a descriptor ring has been allocated, it may be reinitialized for
356* use with additional/different regions of memory.
357*
358* Note that if 7 descriptors are allocated, it's perfectly acceptable to
359* initialize the ring with a smaller number of descriptors. The amount
360* of memory allocated for the descriptor ring will not be reduced, and
361* the descriptor ring may be reinitialized later
362*
363* @return
364* 0 Descriptor ring was initialized successfully
365* -ENOMEM The descriptor which was passed in has insufficient space
366* to hold the desired number of descriptors.
367*/
368/****************************************************************************/
369
370int dma_init_descriptor_ring(DMA_DescriptorRing_t *ring, /* Descriptor ring to initialize */
371 int numDescriptors /* Number of descriptors to initialize. */
372 );
373
374/****************************************************************************/
375/**
376* Determines the number of descriptors which would be required for a
377* transfer of the indicated memory region.
378*
379* This function also needs to know which DMA device this transfer will
380* be destined for, so that the appropriate DMA configuration can be retrieved.
381* DMA parameters such as transfer width, and whether this is a memory-to-memory
382* or memory-to-peripheral, etc can all affect the actual number of descriptors
383* required.
384*
385* @return
386* > 0 Returns the number of descriptors required for the indicated transfer
387* -EINVAL Invalid device type for this kind of transfer
388* (i.e. the device is _MEM_TO_DEV and not _DEV_TO_MEM)
389* -ENOMEM Memory exhausted
390*/
391/****************************************************************************/
392
393int dma_calculate_descriptor_count(DMA_Device_t device, /* DMA Device that this will be associated with */
394 dma_addr_t srcData, /* Place to get data to write to device */
395 dma_addr_t dstData, /* Pointer to device data address */
396 size_t numBytes /* Number of bytes to transfer to the device */
397 );
398
399/****************************************************************************/
400/**
401* Adds a region of memory to the descriptor ring. Note that it may take
402* multiple descriptors for each region of memory. It is the callers
403* responsibility to allocate a sufficiently large descriptor ring.
404*
405* @return
406* 0 Descriptors were added successfully
407* -EINVAL Invalid device type for this kind of transfer
408* (i.e. the device is _MEM_TO_DEV and not _DEV_TO_MEM)
409* -ENOMEM Memory exhausted
410*/
411/****************************************************************************/
412
413int dma_add_descriptors(DMA_DescriptorRing_t *ring, /* Descriptor ring to add descriptors to */
414 DMA_Device_t device, /* DMA Device that descriptors are for */
415 dma_addr_t srcData, /* Place to get data (memory or device) */
416 dma_addr_t dstData, /* Place to put data (memory or device) */
417 size_t numBytes /* Number of bytes to transfer to the device */
418 );
419
420/****************************************************************************/
421/**
422* Sets the descriptor ring associated with a device.
423*
424* Once set, the descriptor ring will be associated with the device, even
425* across channel request/free calls. Passing in a NULL descriptor ring
426* will release any descriptor ring currently associated with the device.
427*
428* Note: If you call dma_transfer, or one of the other dma_alloc_ functions
429* the descriptor ring may be released and reallocated.
430*
431* Note: This function will release the descriptor memory for any current
432* descriptor ring associated with this device.
433*/
434/****************************************************************************/
435
436int dma_set_device_descriptor_ring(DMA_Device_t device, /* Device to update the descriptor ring for. */
437 DMA_DescriptorRing_t *ring /* Descriptor ring to add descriptors to */
438 );
439
440/****************************************************************************/
441/**
442* Retrieves the descriptor ring associated with a device.
443*/
444/****************************************************************************/
445
446int dma_get_device_descriptor_ring(DMA_Device_t device, /* Device to retrieve the descriptor ring for. */
447 DMA_DescriptorRing_t *ring /* Place to store retrieved ring */
448 );
449
450/****************************************************************************/
451/**
452* Allocates buffers for the descriptors. This is normally done automatically
453* but needs to be done explicitly when initiating a dma from interrupt
454* context.
455*
456* @return
457* 0 Descriptors were allocated successfully
458* -EINVAL Invalid device type for this kind of transfer
459* (i.e. the device is _MEM_TO_DEV and not _DEV_TO_MEM)
460* -ENOMEM Memory exhausted
461*/
462/****************************************************************************/
463
464int dma_alloc_descriptors(DMA_Handle_t handle, /* DMA Handle */
465 dmacHw_TRANSFER_TYPE_e transferType, /* Type of transfer being performed */
466 dma_addr_t srcData, /* Place to get data to write to device */
467 dma_addr_t dstData, /* Pointer to device data address */
468 size_t numBytes /* Number of bytes to transfer to the device */
469 );
470
471/****************************************************************************/
472/**
473* Allocates and sets up descriptors for a double buffered circular buffer.
474*
475* This is primarily intended to be used for things like the ingress samples
476* from a microphone.
477*
478* @return
479* > 0 Number of descriptors actually allocated.
480* -EINVAL Invalid device type for this kind of transfer
481* (i.e. the device is _MEM_TO_DEV and not _DEV_TO_MEM)
482* -ENOMEM Memory exhausted
483*/
484/****************************************************************************/
485
486int dma_alloc_double_dst_descriptors(DMA_Handle_t handle, /* DMA Handle */
487 dma_addr_t srcData, /* Physical address of source data */
488 dma_addr_t dstData1, /* Physical address of first destination buffer */
489 dma_addr_t dstData2, /* Physical address of second destination buffer */
490 size_t numBytes /* Number of bytes in each destination buffer */
491 );
492
493/****************************************************************************/
494/**
495* Initiates a transfer when the descriptors have already been setup.
496*
497* This is a special case, and normally, the dma_transfer_xxx functions should
498* be used.
499*
500* @return
501* 0 Transfer was started successfully
502* -ENODEV Invalid handle
503*/
504/****************************************************************************/
505
506int dma_start_transfer(DMA_Handle_t handle);
507
508/****************************************************************************/
509/**
510* Stops a previously started DMA transfer.
511*
512* @return
513* 0 Transfer was stopped successfully
514* -ENODEV Invalid handle
515*/
516/****************************************************************************/
517
518int dma_stop_transfer(DMA_Handle_t handle);
519
520/****************************************************************************/
521/**
522* Waits for a DMA to complete by polling. This function is only intended
523* to be used for testing. Interrupts should be used for most DMA operations.
524*/
525/****************************************************************************/
526
527int dma_wait_transfer_done(DMA_Handle_t handle);
528
529/****************************************************************************/
530/**
531* Initiates a DMA transfer
532*
533* @return
534* 0 Transfer was started successfully
535* -EINVAL Invalid device type for this kind of transfer
536* (i.e. the device is _MEM_TO_DEV and not _DEV_TO_MEM)
537*/
538/****************************************************************************/
539
540int dma_transfer(DMA_Handle_t handle, /* DMA Handle */
541 dmacHw_TRANSFER_TYPE_e transferType, /* Type of transfer being performed */
542 dma_addr_t srcData, /* Place to get data to write to device */
543 dma_addr_t dstData, /* Pointer to device data address */
544 size_t numBytes /* Number of bytes to transfer to the device */
545 );
546
547/****************************************************************************/
548/**
549* Initiates a transfer from memory to a device.
550*
551* @return
552* 0 Transfer was started successfully
553* -EINVAL Invalid device type for this kind of transfer
554* (i.e. the device is _DEV_TO_MEM and not _MEM_TO_DEV)
555*/
556/****************************************************************************/
557
558static inline int dma_transfer_to_device(DMA_Handle_t handle, /* DMA Handle */
559 dma_addr_t srcData, /* Place to get data to write to device (physical address) */
560 dma_addr_t dstData, /* Pointer to device data address (physical address) */
561 size_t numBytes /* Number of bytes to transfer to the device */
562 ) {
563 return dma_transfer(handle,
564 dmacHw_TRANSFER_TYPE_MEM_TO_PERIPHERAL,
565 srcData, dstData, numBytes);
566}
567
568/****************************************************************************/
569/**
570* Initiates a transfer from a device to memory.
571*
572* @return
573* 0 Transfer was started successfully
574* -EINVAL Invalid device type for this kind of transfer
575* (i.e. the device is _MEM_TO_DEV and not _DEV_TO_MEM)
576*/
577/****************************************************************************/
578
579static inline int dma_transfer_from_device(DMA_Handle_t handle, /* DMA Handle */
580 dma_addr_t srcData, /* Pointer to the device data address (physical address) */
581 dma_addr_t dstData, /* Place to store data retrieved from the device (physical address) */
582 size_t numBytes /* Number of bytes to retrieve from the device */
583 ) {
584 return dma_transfer(handle,
585 dmacHw_TRANSFER_TYPE_PERIPHERAL_TO_MEM,
586 srcData, dstData, numBytes);
587}
588
589/****************************************************************************/
590/**
591* Initiates a memory to memory transfer.
592*
593* @return
594* 0 Transfer was started successfully
595* -EINVAL Invalid device type for this kind of transfer
596* (i.e. the device wasn't DMA_DEVICE_MEM_TO_MEM)
597*/
598/****************************************************************************/
599
600static inline int dma_transfer_mem_to_mem(DMA_Handle_t handle, /* DMA Handle */
601 dma_addr_t srcData, /* Place to transfer data from (physical address) */
602 dma_addr_t dstData, /* Place to transfer data to (physical address) */
603 size_t numBytes /* Number of bytes to transfer */
604 ) {
605 return dma_transfer(handle,
606 dmacHw_TRANSFER_TYPE_MEM_TO_MEM,
607 srcData, dstData, numBytes);
608}
609
610/****************************************************************************/
611/**
612* Set the callback function which will be called when a transfer completes.
613* If a NULL callback function is set, then no callback will occur.
614*
615* @note @a devHandler will be called from IRQ context.
616*
617* @return
618* 0 - Success
619* -ENODEV - Device handed in is invalid.
620*/
621/****************************************************************************/
622
623int dma_set_device_handler(DMA_Device_t dev, /* Device to set the callback for. */
624 DMA_DeviceHandler_t devHandler, /* Function to call when the DMA completes */
625 void *userData /* Pointer which will be passed to devHandler. */
626 );
627
628#endif
629
630#endif /* ASM_ARM_ARCH_BCMRING_DMA_H */