diff options
Diffstat (limited to 'arch/arm/mach-bcmring/include/mach/dma.h')
-rw-r--r-- | arch/arm/mach-bcmring/include/mach/dma.h | 630 |
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 | |||
43 | typedef 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 | |||
91 | typedef 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 | |||
100 | typedef 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 | |||
126 | typedef 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 | |||
142 | typedef 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 | |||
207 | typedef 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 | |||
232 | typedef 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 | |||
247 | typedef 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 | |||
257 | extern 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 | |||
273 | int dma_init(void); | ||
274 | |||
275 | #if (DMA_DEBUG_TRACK_RESERVATION) | ||
276 | DMA_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 | |||
294 | DMA_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 | |||
308 | int 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 | |||
322 | int 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 | |||
339 | int 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 | |||
349 | void 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 | |||
370 | int 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 | |||
393 | int 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 | |||
413 | int 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 | |||
436 | int 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 | |||
446 | int 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 | |||
464 | int 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 | |||
486 | int 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 | |||
506 | int 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 | |||
518 | int 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 | |||
527 | int 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 | |||
540 | int 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 | |||
558 | static 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 | |||
579 | static 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 | |||
600 | static 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 | |||
623 | int 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 */ | ||