board: xilinx: Remove unused ancient i2c driver
[karo-tx-uboot.git] / board / xilinx / common / xdma_channel.c
1 /******************************************************************************
2 *
3 *     Author: Xilinx, Inc.
4 *
5 *
6 *     This program is free software; you can redistribute it and/or modify it
7 *     under the terms of the GNU General Public License as published by the
8 *     Free Software Foundation; either version 2 of the License, or (at your
9 *     option) any later version.
10 *
11 *
12 *     XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS" AS A
13 *     COURTESY TO YOU. BY PROVIDING THIS DESIGN, CODE, OR INFORMATION AS
14 *     ONE POSSIBLE IMPLEMENTATION OF THIS FEATURE, APPLICATION OR STANDARD,
15 *     XILINX IS MAKING NO REPRESENTATION THAT THIS IMPLEMENTATION IS FREE
16 *     FROM ANY CLAIMS OF INFRINGEMENT, AND YOU ARE RESPONSIBLE FOR OBTAINING
17 *     ANY THIRD PARTY RIGHTS YOU MAY REQUIRE FOR YOUR IMPLEMENTATION.
18 *     XILINX EXPRESSLY DISCLAIMS ANY WARRANTY WHATSOEVER WITH RESPECT TO
19 *     THE ADEQUACY OF THE IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO ANY
20 *     WARRANTIES OR REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE FROM
21 *     CLAIMS OF INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY AND
22 *     FITNESS FOR A PARTICULAR PURPOSE.
23 *
24 *
25 *     Xilinx hardware products are not intended for use in life support
26 *     appliances, devices, or systems. Use in such applications is
27 *     expressly prohibited.
28 *
29 *
30 *     (c) Copyright 2002-2004 Xilinx Inc.
31 *     All rights reserved.
32 *
33 *
34 *     You should have received a copy of the GNU General Public License along
35 *     with this program; if not, write to the Free Software Foundation, Inc.,
36 *     675 Mass Ave, Cambridge, MA 02139, USA.
37 *
38 * FILENAME:
39 *
40 * xdma_channel.c
41 *
42 * DESCRIPTION:
43 *
44 * This file contains the DMA channel component. This component supports
45 * a distributed DMA design in which each device can have it's own dedicated
46 * DMA channel, as opposed to a centralized DMA design. This component
47 * performs processing for DMA on all devices.
48 *
49 * See xdma_channel.h for more information about this component.
50 *
51 * NOTES:
52 *
53 * None.
54 *
55 ******************************************************************************/
56
57 /***************************** Include Files *********************************/
58
59 #include "xdma_channel.h"
60 #include "xbasic_types.h"
61 #include "xio.h"
62
63 /************************** Constant Definitions *****************************/
64
65 /**************************** Type Definitions *******************************/
66
67 /***************** Macros (Inline Functions) Definitions *********************/
68
69 /************************** Function Prototypes ******************************/
70
71 /******************************************************************************
72 *
73 * FUNCTION:
74 *
75 * XDmaChannel_Initialize
76 *
77 * DESCRIPTION:
78 *
79 * This function initializes a DMA channel.  This function must be called
80 * prior to using a DMA channel.  Initialization of a channel includes setting
81 * up the registers base address, and resetting the channel such that it's in a
82 * known state.  Interrupts for the channel are disabled when the channel is
83 * reset.
84 *
85 * ARGUMENTS:
86 *
87 * InstancePtr contains a pointer to the DMA channel to operate on.
88 *
89 * BaseAddress contains the base address of the registers for the DMA channel.
90 *
91 * RETURN VALUE:
92 *
93 * XST_SUCCESS indicating initialization was successful.
94 *
95 * NOTES:
96 *
97 * None.
98 *
99 ******************************************************************************/
100 XStatus
101 XDmaChannel_Initialize(XDmaChannel * InstancePtr, u32 BaseAddress)
102 {
103         /* assert to verify input arguments, don't assert base address */
104
105         XASSERT_NONVOID(InstancePtr != NULL);
106
107         /* setup the base address of the registers for the DMA channel such
108          * that register accesses can be done
109          */
110         InstancePtr->RegBaseAddress = BaseAddress;
111
112         /* initialize the scatter gather list such that it indicates it has not
113          * been created yet and the DMA channel is ready to use (initialized)
114          */
115         InstancePtr->GetPtr = NULL;
116         InstancePtr->PutPtr = NULL;
117         InstancePtr->CommitPtr = NULL;
118         InstancePtr->LastPtr = NULL;
119
120         InstancePtr->TotalDescriptorCount = 0;
121         InstancePtr->ActiveDescriptorCount = 0;
122         InstancePtr->IsReady = XCOMPONENT_IS_READY;
123
124         /* initialize the version of the component
125          */
126         XVersion_FromString(&InstancePtr->Version, (s8 *)"1.00a");
127
128         /* reset the DMA channel such that it's in a known state and ready
129          * and indicate the initialization occured with no errors, note that
130          * the is ready variable must be set before this call or reset will assert
131          */
132         XDmaChannel_Reset(InstancePtr);
133
134         return XST_SUCCESS;
135 }
136
137 /******************************************************************************
138 *
139 * FUNCTION:
140 *
141 * XDmaChannel_IsReady
142 *
143 * DESCRIPTION:
144 *
145 * This function determines if a DMA channel component has been successfully
146 * initialized such that it's ready to use.
147 *
148 * ARGUMENTS:
149 *
150 * InstancePtr contains a pointer to the DMA channel to operate on.
151 *
152 * RETURN VALUE:
153 *
154 * TRUE if the DMA channel component is ready, FALSE otherwise.
155 *
156 * NOTES:
157 *
158 * None.
159 *
160 ******************************************************************************/
161 u32
162 XDmaChannel_IsReady(XDmaChannel * InstancePtr)
163 {
164         /* assert to verify input arguments used by the base component */
165
166         XASSERT_NONVOID(InstancePtr != NULL);
167
168         return InstancePtr->IsReady == XCOMPONENT_IS_READY;
169 }
170
171 /******************************************************************************
172 *
173 * FUNCTION:
174 *
175 * XDmaChannel_GetVersion
176 *
177 * DESCRIPTION:
178 *
179 * This function gets the software version for the specified DMA channel
180 * component.
181 *
182 * ARGUMENTS:
183 *
184 * InstancePtr contains a pointer to the DMA channel to operate on.
185 *
186 * RETURN VALUE:
187 *
188 * A pointer to the software version of the specified DMA channel.
189 *
190 * NOTES:
191 *
192 * None.
193 *
194 ******************************************************************************/
195 XVersion *
196 XDmaChannel_GetVersion(XDmaChannel * InstancePtr)
197 {
198         /* assert to verify input arguments */
199
200         XASSERT_NONVOID(InstancePtr != NULL);
201         XASSERT_NONVOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);
202
203         /* return a pointer to the version of the DMA channel */
204
205         return &InstancePtr->Version;
206 }
207
208 /******************************************************************************
209 *
210 * FUNCTION:
211 *
212 * XDmaChannel_SelfTest
213 *
214 * DESCRIPTION:
215 *
216 * This function performs a self test on the specified DMA channel.  This self
217 * test is destructive as the DMA channel is reset and a register default is
218 * verified.
219 *
220 * ARGUMENTS:
221 *
222 * InstancePtr is a pointer to the DMA channel to be operated on.
223 *
224 * RETURN VALUE:
225 *
226 * XST_SUCCESS is returned if the self test is successful, or one of the
227 * following errors.
228 *
229 *       XST_DMA_RESET_REGISTER_ERROR            Indicates the control register value
230 *                                                                               after a reset was not correct
231 *
232 * NOTES:
233 *
234 * This test does not performs a DMA transfer to test the channel because the
235 * DMA hardware will not currently allow a non-local memory transfer to non-local
236 * memory (memory copy), but only allows a non-local memory to or from the device
237 * memory (typically a FIFO).
238 *
239 ******************************************************************************/
240
241 #define XDC_CONTROL_REG_RESET_MASK  0x98000000UL        /* control reg reset value */
242
243 XStatus
244 XDmaChannel_SelfTest(XDmaChannel * InstancePtr)
245 {
246         u32 ControlReg;
247
248         /* assert to verify input arguments */
249
250         XASSERT_NONVOID(InstancePtr != NULL);
251         XASSERT_NONVOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);
252
253         /* reset the DMA channel such that it's in a known state before the test
254          * it resets to no interrupts enabled, the desired state for the test
255          */
256         XDmaChannel_Reset(InstancePtr);
257
258         /* this should be the first test to help prevent a lock up with the polling
259          * loop that occurs later in the test, check the reset value of the DMA
260          * control register to make sure it's correct, return with an error if not
261          */
262         ControlReg = XDmaChannel_GetControl(InstancePtr);
263         if (ControlReg != XDC_CONTROL_REG_RESET_MASK) {
264                 return XST_DMA_RESET_REGISTER_ERROR;
265         }
266
267         return XST_SUCCESS;
268 }
269
270 /******************************************************************************
271 *
272 * FUNCTION:
273 *
274 * XDmaChannel_Reset
275 *
276 * DESCRIPTION:
277 *
278 * This function resets the DMA channel. This is a destructive operation such
279 * that it should not be done while a channel is being used.  If the DMA channel
280 * is transferring data into other blocks, such as a FIFO, it may be necessary
281 * to reset other blocks.  This function does not modify the contents of a
282 * scatter gather list for a DMA channel such that the user is responsible for
283 * getting buffer descriptors from the list if necessary.
284 *
285 * ARGUMENTS:
286 *
287 * InstancePtr contains a pointer to the DMA channel to operate on.
288 *
289 * RETURN VALUE:
290 *
291 * None.
292 *
293 * NOTES:
294 *
295 * None.
296 *
297 ******************************************************************************/
298 void
299 XDmaChannel_Reset(XDmaChannel * InstancePtr)
300 {
301         /* assert to verify input arguments */
302
303         XASSERT_VOID(InstancePtr != NULL);
304         XASSERT_VOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);
305
306         /* reset the DMA channel such that it's in a known state, the reset
307          * register is self clearing such that it only has to be set
308          */
309         XIo_Out32(InstancePtr->RegBaseAddress + XDC_RST_REG_OFFSET,
310                   XDC_RESET_MASK);
311 }
312
313 /******************************************************************************
314 *
315 * FUNCTION:
316 *
317 * XDmaChannel_GetControl
318 *
319 * DESCRIPTION:
320 *
321 * This function gets the control register contents of the DMA channel.
322 *
323 * ARGUMENTS:
324 *
325 * InstancePtr contains a pointer to the DMA channel to operate on.
326 *
327 * RETURN VALUE:
328 *
329 * The control register contents of the DMA channel. One or more of the
330 * following values may be contained the register.  Each of the values are
331 * unique bit masks.
332 *
333 *       XDC_DMACR_SOURCE_INCR_MASK      Increment the source address
334 *       XDC_DMACR_DEST_INCR_MASK        Increment the destination address
335 *       XDC_DMACR_SOURCE_LOCAL_MASK Local source address
336 *       XDC_DMACR_DEST_LOCAL_MASK       Local destination address
337 *       XDC_DMACR_SG_ENABLE_MASK        Scatter gather enable
338 *       XDC_DMACR_GEN_BD_INTR_MASK      Individual buffer descriptor interrupt
339 *       XDC_DMACR_LAST_BD_MASK          Last buffer descriptor in a packet
340 *
341 * NOTES:
342 *
343 * None.
344 *
345 ******************************************************************************/
346 u32
347 XDmaChannel_GetControl(XDmaChannel * InstancePtr)
348 {
349         /* assert to verify input arguments */
350
351         XASSERT_NONVOID(InstancePtr != NULL);
352         XASSERT_NONVOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);
353
354         /* return the contents of the DMA control register */
355
356         return XIo_In32(InstancePtr->RegBaseAddress + XDC_DMAC_REG_OFFSET);
357 }
358
359 /******************************************************************************
360 *
361 * FUNCTION:
362 *
363 * XDmaChannel_SetControl
364 *
365 * DESCRIPTION:
366 *
367 * This function sets the control register of the specified DMA channel.
368 *
369 * ARGUMENTS:
370 *
371 * InstancePtr contains a pointer to the DMA channel to operate on.
372 *
373 * Control contains the value to be written to the control register of the DMA
374 * channel. One or more of the following values may be contained the register.
375 * Each of the values are unique bit masks such that they may be ORed together
376 * to enable multiple bits or inverted and ANDed to disable multiple bits.
377 *
378 *       XDC_DMACR_SOURCE_INCR_MASK      Increment the source address
379 *       XDC_DMACR_DEST_INCR_MASK        Increment the destination address
380 *       XDC_DMACR_SOURCE_LOCAL_MASK Local source address
381 *       XDC_DMACR_DEST_LOCAL_MASK       Local destination address
382 *       XDC_DMACR_SG_ENABLE_MASK        Scatter gather enable
383 *       XDC_DMACR_GEN_BD_INTR_MASK      Individual buffer descriptor interrupt
384 *       XDC_DMACR_LAST_BD_MASK          Last buffer descriptor in a packet
385 *
386 * RETURN VALUE:
387 *
388 * None.
389 *
390 * NOTES:
391 *
392 * None.
393 *
394 ******************************************************************************/
395 void
396 XDmaChannel_SetControl(XDmaChannel * InstancePtr, u32 Control)
397 {
398         /* assert to verify input arguments except the control which can't be
399          * asserted since all values are valid
400          */
401         XASSERT_VOID(InstancePtr != NULL);
402         XASSERT_VOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);
403
404         /* set the DMA control register to the specified value */
405
406         XIo_Out32(InstancePtr->RegBaseAddress + XDC_DMAC_REG_OFFSET, Control);
407 }
408
409 /******************************************************************************
410 *
411 * FUNCTION:
412 *
413 * XDmaChannel_GetStatus
414 *
415 * DESCRIPTION:
416 *
417 * This function gets the status register contents of the DMA channel.
418 *
419 * ARGUMENTS:
420 *
421 * InstancePtr contains a pointer to the DMA channel to operate on.
422 *
423 * RETURN VALUE:
424 *
425 * The status register contents of the DMA channel. One or more of the
426 * following values may be contained the register. Each of the values are
427 * unique bit masks.
428 *
429 *       XDC_DMASR_BUSY_MASK                     The DMA channel is busy
430 *       XDC_DMASR_BUS_ERROR_MASK        A bus error occurred
431 *       XDC_DMASR_BUS_TIMEOUT_MASK      A bus timeout occurred
432 *       XDC_DMASR_LAST_BD_MASK          The last buffer descriptor of a packet
433 *
434 * NOTES:
435 *
436 * None.
437 *
438 ******************************************************************************/
439 u32
440 XDmaChannel_GetStatus(XDmaChannel * InstancePtr)
441 {
442         /* assert to verify input arguments */
443
444         XASSERT_NONVOID(InstancePtr != NULL);
445         XASSERT_NONVOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);
446
447         /* return the contents of the DMA status register */
448
449         return XIo_In32(InstancePtr->RegBaseAddress + XDC_DMAS_REG_OFFSET);
450 }
451
452 /******************************************************************************
453 *
454 * FUNCTION:
455 *
456 * XDmaChannel_SetIntrStatus
457 *
458 * DESCRIPTION:
459 *
460 * This function sets the interrupt status register of the specified DMA channel.
461 * Setting any bit of the interrupt status register will clear the bit to
462 * indicate the interrupt processing has been completed. The definitions of each
463 * bit in the register match the definition of the bits in the interrupt enable
464 * register.
465 *
466 * ARGUMENTS:
467 *
468 * InstancePtr contains a pointer to the DMA channel to operate on.
469 *
470 * Status contains the value to be written to the status register of the DMA
471 * channel.  One or more of the following values may be contained the register.
472 * Each of the values are unique bit masks such that they may be ORed together
473 * to enable multiple bits or inverted and ANDed to disable multiple bits.
474 *
475 *       XDC_IXR_DMA_DONE_MASK           The dma operation is done
476 *       XDC_IXR_DMA_ERROR_MASK      The dma operation had an error
477 *       XDC_IXR_PKT_DONE_MASK       A packet is complete
478 *       XDC_IXR_PKT_THRESHOLD_MASK      The packet count threshold reached
479 *       XDC_IXR_PKT_WAIT_BOUND_MASK The packet wait bound reached
480 *       XDC_IXR_SG_DISABLE_ACK_MASK The scatter gather disable completed
481 *       XDC_IXR_BD_MASK                         A buffer descriptor is done
482 *
483 * RETURN VALUE:
484 *
485 * None.
486 *
487 * NOTES:
488 *
489 * None.
490 *
491 ******************************************************************************/
492 void
493 XDmaChannel_SetIntrStatus(XDmaChannel * InstancePtr, u32 Status)
494 {
495         /* assert to verify input arguments except the status which can't be
496          * asserted since all values are valid
497          */
498         XASSERT_VOID(InstancePtr != NULL);
499         XASSERT_VOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);
500
501         /* set the interrupt status register with the specified value such that
502          * all bits which are set in the register are cleared effectively clearing
503          * any active interrupts
504          */
505         XIo_Out32(InstancePtr->RegBaseAddress + XDC_IS_REG_OFFSET, Status);
506 }
507
508 /******************************************************************************
509 *
510 * FUNCTION:
511 *
512 * XDmaChannel_GetIntrStatus
513 *
514 * DESCRIPTION:
515 *
516 * This function gets the interrupt status register of the specified DMA channel.
517 * The interrupt status register indicates which interrupts are active
518 * for the DMA channel.  If an interrupt is active, the status register must be
519 * set (written) with the bit set for each interrupt which has been processed
520 * in order to clear the interrupts.  The definitions of each bit in the register
521 * match the definition of the bits in the interrupt enable register.
522 *
523 * ARGUMENTS:
524 *
525 * InstancePtr contains a pointer to the DMA channel to operate on.
526 *
527 * RETURN VALUE:
528 *
529 * The interrupt status register contents of the specified DMA channel.
530 * One or more of the following values may be contained the register.
531 * Each of the values are unique bit masks.
532 *
533 *       XDC_IXR_DMA_DONE_MASK           The dma operation is done
534 *       XDC_IXR_DMA_ERROR_MASK      The dma operation had an error
535 *       XDC_IXR_PKT_DONE_MASK       A packet is complete
536 *       XDC_IXR_PKT_THRESHOLD_MASK      The packet count threshold reached
537 *       XDC_IXR_PKT_WAIT_BOUND_MASK The packet wait bound reached
538 *       XDC_IXR_SG_DISABLE_ACK_MASK The scatter gather disable completed
539 *       XDC_IXR_SG_END_MASK                     Current descriptor was the end of the list
540 *       XDC_IXR_BD_MASK                         A buffer descriptor is done
541 *
542 * NOTES:
543 *
544 * None.
545 *
546 ******************************************************************************/
547 u32
548 XDmaChannel_GetIntrStatus(XDmaChannel * InstancePtr)
549 {
550         /* assert to verify input arguments */
551
552         XASSERT_NONVOID(InstancePtr != NULL);
553         XASSERT_NONVOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);
554
555         /* return the contents of the interrupt status register */
556
557         return XIo_In32(InstancePtr->RegBaseAddress + XDC_IS_REG_OFFSET);
558 }
559
560 /******************************************************************************
561 *
562 * FUNCTION:
563 *
564 * XDmaChannel_SetIntrEnable
565 *
566 * DESCRIPTION:
567 *
568 * This function sets the interrupt enable register of the specified DMA
569 * channel.  The interrupt enable register contains bits which enable
570 * individual interrupts for the DMA channel.  The definitions of each bit
571 * in the register match the definition of the bits in the interrupt status
572 * register.
573 *
574 * ARGUMENTS:
575 *
576 * InstancePtr contains a pointer to the DMA channel to operate on.
577 *
578 * Enable contains the interrupt enable register contents to be written
579 * in the DMA channel. One or more of the following values may be contained
580 * the register. Each of the values are unique bit masks such that they may be
581 * ORed together to enable multiple bits or inverted and ANDed to disable
582 * multiple bits.
583 *
584 *       XDC_IXR_DMA_DONE_MASK           The dma operation is done
585 *       XDC_IXR_DMA_ERROR_MASK      The dma operation had an error
586 *       XDC_IXR_PKT_DONE_MASK       A packet is complete
587 *       XDC_IXR_PKT_THRESHOLD_MASK      The packet count threshold reached
588 *       XDC_IXR_PKT_WAIT_BOUND_MASK The packet wait bound reached
589 *       XDC_IXR_SG_DISABLE_ACK_MASK The scatter gather disable completed
590 *       XDC_IXR_SG_END_MASK                     Current descriptor was the end of the list
591 *       XDC_IXR_BD_MASK                         A buffer descriptor is done
592 *
593 * RETURN VALUE:
594 *
595 * None.
596 *
597 * NOTES:
598 *
599 * None.
600 *
601 ******************************************************************************/
602 void
603 XDmaChannel_SetIntrEnable(XDmaChannel * InstancePtr, u32 Enable)
604 {
605         /* assert to verify input arguments except the enable which can't be
606          * asserted since all values are valid
607          */
608         XASSERT_VOID(InstancePtr != NULL);
609         XASSERT_VOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);
610
611         /* set the interrupt enable register to the specified value */
612
613         XIo_Out32(InstancePtr->RegBaseAddress + XDC_IE_REG_OFFSET, Enable);
614 }
615
616 /******************************************************************************
617 *
618 * FUNCTION:
619 *
620 * XDmaChannel_GetIntrEnable
621 *
622 * DESCRIPTION:
623 *
624 * This function gets the interrupt enable of the DMA channel.  The
625 * interrupt enable contains flags which enable individual interrupts for the
626 * DMA channel. The definitions of each bit in the register match the definition
627 * of the bits in the interrupt status register.
628 *
629 * ARGUMENTS:
630 *
631 * InstancePtr contains a pointer to the DMA channel to operate on.
632 *
633 * RETURN VALUE:
634 *
635 * The interrupt enable of the DMA channel.  One or more of the following values
636 * may be contained the register. Each of the values are unique bit masks.
637 *
638 *       XDC_IXR_DMA_DONE_MASK           The dma operation is done
639 *       XDC_IXR_DMA_ERROR_MASK      The dma operation had an error
640 *       XDC_IXR_PKT_DONE_MASK       A packet is complete
641 *       XDC_IXR_PKT_THRESHOLD_MASK      The packet count threshold reached
642 *       XDC_IXR_PKT_WAIT_BOUND_MASK The packet wait bound reached
643 *       XDC_IXR_SG_DISABLE_ACK_MASK The scatter gather disable completed
644 *       XDC_IXR_BD_MASK                         A buffer descriptor is done
645 *
646 * NOTES:
647 *
648 * None.
649 *
650 ******************************************************************************/
651 u32
652 XDmaChannel_GetIntrEnable(XDmaChannel * InstancePtr)
653 {
654         /* assert to verify input arguments */
655
656         XASSERT_NONVOID(InstancePtr != NULL);
657         XASSERT_NONVOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);
658
659         /* return the contents of the interrupt enable register */
660
661         return XIo_In32(InstancePtr->RegBaseAddress + XDC_IE_REG_OFFSET);
662 }
663
664 /******************************************************************************
665 *
666 * FUNCTION:
667 *
668 * XDmaChannel_Transfer
669 *
670 * DESCRIPTION:
671 *
672 * This function starts the DMA channel transferring data from a memory source
673 * to a memory destination. This function only starts the operation and returns
674 * before the operation may be complete.  If the interrupt is enabled, an
675 * interrupt will be generated when the operation is complete, otherwise it is
676 * necessary to poll the channel status to determine when it's complete.  It is
677 * the responsibility of the caller to determine when the operation is complete
678 * by handling the generated interrupt or polling the status.  It is also the
679 * responsibility of the caller to ensure that the DMA channel is not busy with
680 * another transfer before calling this function.
681 *
682 * ARGUMENTS:
683 *
684 * InstancePtr contains a pointer to the DMA channel to operate on.
685 *
686 * SourcePtr contains a pointer to the source memory where the data is to
687 * be tranferred from and must be 32 bit aligned.
688 *
689 * DestinationPtr contains a pointer to the destination memory where the data
690 * is to be transferred and must be 32 bit aligned.
691 *
692 * ByteCount contains the number of bytes to transfer during the DMA operation.
693 *
694 * RETURN VALUE:
695 *
696 * None.
697 *
698 * NOTES:
699 *
700 * The DMA h/w will not currently allow a non-local memory transfer to non-local
701 * memory (memory copy), but only allows a non-local memory to or from the device
702 * memory (typically a FIFO).
703 *
704 * It is the responsibility of the caller to ensure that the cache is
705 * flushed and invalidated both before and after the DMA operation completes
706 * if the memory pointed to is cached. The caller must also ensure that the
707 * pointers contain a physical address rather than a virtual address
708 * if address translation is being used.
709 *
710 ******************************************************************************/
711 void
712 XDmaChannel_Transfer(XDmaChannel * InstancePtr,
713                      u32 * SourcePtr, u32 * DestinationPtr, u32 ByteCount)
714 {
715         /* assert to verify input arguments and the alignment of any arguments
716          * which have expected alignments
717          */
718         XASSERT_VOID(InstancePtr != NULL);
719         XASSERT_VOID(SourcePtr != NULL);
720         XASSERT_VOID(((u32) SourcePtr & 3) == 0);
721         XASSERT_VOID(DestinationPtr != NULL);
722         XASSERT_VOID(((u32) DestinationPtr & 3) == 0);
723         XASSERT_VOID(ByteCount != 0);
724         XASSERT_VOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);
725
726         /* setup the source and destination address registers for the transfer */
727
728         XIo_Out32(InstancePtr->RegBaseAddress + XDC_SA_REG_OFFSET,
729                   (u32) SourcePtr);
730
731         XIo_Out32(InstancePtr->RegBaseAddress + XDC_DA_REG_OFFSET,
732                   (u32) DestinationPtr);
733
734         /* start the DMA transfer to copy from the source buffer to the
735          * destination buffer by writing the length to the length register
736          */
737         XIo_Out32(InstancePtr->RegBaseAddress + XDC_LEN_REG_OFFSET, ByteCount);
738 }