[karo-tx-uboot.git] / board / xilinx / common / xdma_channel_sg.c

/* $Id: xdma_channel_sg.c,v 1.6 2003/02/03 19:50:33 moleres Exp $ */
/******************************************************************************
*
*     Author: Xilinx, Inc.
*
*
*     This program is free software; you can redistribute it and/or modify it
*     under the terms of the GNU General Public License as published by the
*     Free Software Foundation; either version 2 of the License, or (at your
*     option) any later version.
*
*
*     XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS" AS A
*     COURTESY TO YOU. BY PROVIDING THIS DESIGN, CODE, OR INFORMATION AS
*     ONE POSSIBLE IMPLEMENTATION OF THIS FEATURE, APPLICATION OR STANDARD,
*     XILINX IS MAKING NO REPRESENTATION THAT THIS IMPLEMENTATION IS FREE
*     FROM ANY CLAIMS OF INFRINGEMENT, AND YOU ARE RESPONSIBLE FOR OBTAINING
*     ANY THIRD PARTY RIGHTS YOU MAY REQUIRE FOR YOUR IMPLEMENTATION.
*     XILINX EXPRESSLY DISCLAIMS ANY WARRANTY WHATSOEVER WITH RESPECT TO
*     THE ADEQUACY OF THE IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO ANY
*     WARRANTIES OR REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE FROM
*     CLAIMS OF INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY AND
*     FITNESS FOR A PARTICULAR PURPOSE.
*
*
*     Xilinx hardware products are not intended for use in life support
*     appliances, devices, or systems. Use in such applications is
*     expressly prohibited.
*
*
*     (c) Copyright 2002-2004 Xilinx Inc.
*     All rights reserved.
*
*
*     You should have received a copy of the GNU General Public License along
*     with this program; if not, write to the Free Software Foundation, Inc.,
*     675 Mass Ave, Cambridge, MA 02139, USA.
*
* FILENAME:
*
* xdma_channel_sg.c
*
* DESCRIPTION:
*
* This file contains the implementation of the XDmaChannel component which is
* related to scatter gather operations.
*
* Scatter Gather Operations
*
* The DMA channel may support scatter gather operations. A scatter gather
* operation automates the DMA channel such that multiple buffers can be
* sent or received with minimal software interaction with the hardware.  Buffer
* descriptors, contained in the XBufDescriptor component, are used by the
* scatter gather operations of the DMA channel to describe the buffers to be
* processed.
*
* Scatter Gather List Operations
*
* A scatter gather list may be supported by each DMA channel.  The scatter
* gather list allows buffer descriptors to be put into the list by a device
* driver which requires scatter gather.  The hardware processes the buffer
* descriptors which are contained in the list and modifies the buffer
* descriptors to reflect the status of the DMA operations.  The device driver
* is notified by interrupt that specific DMA events occur including scatter
* gather events.  The device driver removes the completed buffer descriptors
* from the scatter gather list to evaluate the status of each DMA operation.
*
* The scatter gather list is created and buffer descriptors are inserted into
* the list.  Buffer descriptors are never removed from the list after it's
* creation such that a put operation copies from a temporary buffer descriptor
* to a buffer descriptor in the list.  Get operations don't copy from the list
* to a temporary, but return a pointer to the buffer descriptor in the list.
* A buffer descriptor in the list may be locked to prevent it from being
* overwritten by a put operation.  This allows the device driver to get a
* descriptor from a scatter gather list and prevent it from being overwritten
* until the buffer associated with the buffer descriptor has been processed.
*
* The get and put functions only operate on the list and are asynchronous from
* the hardware which may be using the list of descriptors.  This is important
* because there are no checks in the get and put functions to ensure that the
* hardware has processed the descriptors.  This must be handled by the driver
* using the DMA scatter gather channel through the use of the other functions.
* When a scatter gather operation is started, the start function does ensure
* that the descriptor to start has not already been processed by the hardware
* and is not the first of a series of descriptors that have not been committed
* yet.
*
* Descriptors are put into the list but not marked as ready to use by the
* hardware until a commit operation is done.  This allows multiple descriptors
* which may contain a single packet of information for a protocol to be
* guaranteed not to cause any underflow conditions during transmission. The
* hardware design only allows descriptors to cause it to stop after a descriptor
* has been processed rather than before it is processed.  A series of
* descriptors are put into the list followed by a commit operation, or each
* descriptor may be commited.  A commit operation is performed by changing a
* single descriptor, the first of the series of puts, to indicate that the
* hardware may now use all descriptors after it.  The last descriptor in the
* list is always set to cause the hardware to stop after it is processed.
*
* Typical Scatter Gather Processing
*
* The following steps illustrate the typical processing to use the
* scatter gather features of a DMA channel.
*
* 1. Create a scatter gather list for the DMA channel which puts empty buffer
*    descriptors into the list.
* 2. Create buffer descriptors which describe the buffers to be filled with
*    receive data or the buffers which contain data to be sent.
* 3. Put buffer descriptors into the DMA channel scatter list such that scatter
*    gather operations are requested.
* 4. Commit the buffer descriptors in the list such that they are ready to be
*    used by the DMA channel hardware.
* 5. Start the scatter gather operations of the DMA channel.
* 6. Process any interrupts which occur as a result of the scatter gather
*    operations or poll the DMA channel to determine the status.  This may
*    be accomplished by getting the packet count for the channel and then
*    getting the appropriate number of descriptors from the list for that
*    number of packets.
*
* Minimizing Interrupts
*
* The Scatter Gather operating mode is designed to reduce the amount of CPU
* throughput necessary to manage the hardware for devices. A key to the CPU
* throughput is the number and rate of interrupts that the CPU must service.
* Devices with higher data rates can cause larger numbers of interrupts and
* higher frequency interrupts. Ideally the number of interrupts can be reduced
* by only generating an interrupt when a specific amount of data has been
* received from the interface. This design suffers from a lack of interrupts
* when the amount of data received is less than the specified amount of data
* to generate an interrupt. In order to help minimize the number of interrupts
* which the CPU must service, an algorithm referred to as "interrupt coalescing"
* is utilized.
*
* Interrupt Coalescing
*
* The principle of interrupt coalescing is to wait before generating an
* interrupt until a certain number of packets have been received or sent. An
* interrupt is also generated if a smaller number of packets have been received
* followed by a certain period of time with no packet reception. This is a
* trade-off of latency for bandwidth and is accomplished using several
* mechanisms of the hardware including a counter for packets received or
* transmitted and a packet timer. These two hardware mechanisms work in
* combination to allow a reduction in the number of interrupts processed by the
* CPU for packet reception.
*
* Unserviced Packet Count
*
* The purpose of the packet counter is to count the number of packets received
* or transmitted and provide an interrupt when a specific number of packets
* have been processed by the hardware. An interrupt is generated whenever the
* counter is greater than or equal to the Packet Count Threshold. This counter
* contains an accurate count of the number of packets that the hardware has
* processed, either received or transmitted, and the software has not serviced.
*
* The packet counter allows the number of interrupts to be reduced by waiting
* to generate an interrupt until enough packets are received. For packet
* reception, packet counts of less than the number to generate an interrupt
* would not be serviced without the addition of a packet timer. This counter is
* continuously updated by the hardware, not latched to the value at the time
* the interrupt occurred.
*
* The packet counter can be used within the interrupt service routine for the
* device to reduce the number of interrupts. The interrupt service routine
* loops while performing processing for each packet which has been received or
* transmitted and decrements the counter by a specified value. At the same time,
* the hardware is possibly continuing to receive or transmit more packets such
* that the software may choose, based upon the value in the packet counter, to
* remain in the interrupt service routine rather than exiting and immediately
* returning. This feature should be used with caution as reducing the number of
* interrupts is beneficial, but unbounded interrupt processing is not desirable.
*
* Since the hardware may be incrementing the packet counter simultaneously
* with the software decrementing the counter, there is a need for atomic
* operations. The hardware ensures that the operation is atomic such that
* simultaneous accesses are properly handled.
*
* Packet Wait Bound
*
* The purpose of the packet wait bound is to augment the unserviced packet
* count. Whenever there is no pending interrupt for the channel and the
* unserviced packet count is non-zero, a timer starts counting timeout at the
* value contained the the packet wait bound register.  If the timeout is
* reached, an interrupt is generated such that the software may service the
* data which was buffered.
*
* NOTES:
*
* Special Test Conditions:
*
* The scatter gather list processing must be thoroughly tested if changes are
* made.  Testing should include putting and committing single descriptors and
* putting multiple descriptors followed by a single commit.  There are some
* conditions in the code which handle the exception conditions.
*
* The Put Pointer points to the next location in the descriptor list to copy
* in a new descriptor. The Get Pointer points to the next location in the
* list to get a descriptor from.  The Get Pointer only allows software to
* have a traverse the list after the hardware has finished processing some
* number of descriptors.  The Commit Pointer points to the descriptor in the
* list which is to be committed.  It is also used to determine that no
* descriptor is waiting to be commited (NULL).  The Last Pointer points to
* the last descriptor that was put into the list.  It typically points
* to the previous descriptor to the one pointed to by the Put Pointer.
* Comparisons are done between these pointers to determine when the following
* special conditions exist.

* Single Put And Commit
*
* The buffer descriptor is ready to be used by the hardware so it is important
* for the descriptor to not appear to be waiting to be committed.  The commit
* pointer is reset when a commit is done indicating there are no descriptors
* waiting to be committed.  In all cases but this one, the descriptor is
* changed to cause the hardware to go to the next descriptor after processing
* this one.  But in this case, this is the last descriptor in the list such
* that it must not be changed.
*
* 3 Or More Puts And Commit
*
* A series of 3 or more puts followed by a single commit is different in that
* only the 1st descriptor put into the list is changed when the commit is done.
* This requires each put starting on the 3rd to change the previous descriptor
* so that it allows the hardware to continue to the next descriptor in the list.
*
* The 1st Put Following A Commit
*
* The commit caused the commit pointer to be NULL indicating that there are no
* descriptors waiting to be committed.  It is necessary for the next put to set
* the commit pointer so that a commit must follow the put for the hardware to
* use the descriptor.
*
* <pre>
* MODIFICATION HISTORY:
*
* Ver   Who  Date     Changes
* ----- ---- -------- ------------------------------------------------------
* 1.00a rpm  02/03/03 Removed the XST_DMA_SG_COUNT_EXCEEDED return code
*                     from SetPktThreshold.
* </pre>
*
******************************************************************************/

/***************************** Include Files *********************************/

#include "xdma_channel.h"
#include "xbasic_types.h"
#include "xio.h"
#include "xbuf_descriptor.h"
#include "xstatus.h"

/************************** Constant Definitions *****************************/

#define XDC_SWCR_SG_ENABLE_MASK 0x80000000UL    /* scatter gather enable */

/**************************** Type Definitions *******************************/

/***************** Macros (Inline Functions) Definitions *********************/

/* the following macro copies selected fields of a buffer descriptor to another
 * buffer descriptor, this was provided by the buffer descriptor component but
 * was moved here since it is only used internally to this component and since
 * it does not copy all fields
 */
#define CopyBufferDescriptor(InstancePtr, DestinationPtr)          \
{                                                                  \
    *((u32 *)DestinationPtr + XBD_CONTROL_OFFSET) =            \
        *((u32 *)InstancePtr + XBD_CONTROL_OFFSET);            \
    *((u32 *)DestinationPtr + XBD_SOURCE_OFFSET) =             \
        *((u32 *)InstancePtr + XBD_SOURCE_OFFSET);             \
    *((u32 *)DestinationPtr + XBD_DESTINATION_OFFSET) =        \
        *((u32 *)InstancePtr + XBD_DESTINATION_OFFSET);        \
    *((u32 *)DestinationPtr + XBD_LENGTH_OFFSET) =             \
        *((u32 *)InstancePtr + XBD_LENGTH_OFFSET);             \
    *((u32 *)DestinationPtr + XBD_STATUS_OFFSET) =             \
        *((u32 *)InstancePtr + XBD_STATUS_OFFSET);             \
    *((u32 *)DestinationPtr + XBD_DEVICE_STATUS_OFFSET) =      \
        *((u32 *)InstancePtr + XBD_DEVICE_STATUS_OFFSET);      \
    *((u32 *)DestinationPtr + XBD_ID_OFFSET) =                 \
        *((u32 *)InstancePtr + XBD_ID_OFFSET);                 \
    *((u32 *)DestinationPtr + XBD_FLAGS_OFFSET) =              \
        *((u32 *)InstancePtr + XBD_FLAGS_OFFSET);              \
    *((u32 *)DestinationPtr + XBD_RQSTED_LENGTH_OFFSET) =      \
        *((u32 *)InstancePtr + XBD_RQSTED_LENGTH_OFFSET);      \
}

/************************** Variable Definitions *****************************/

/************************** Function Prototypes ******************************/

/******************************************************************************
*
* FUNCTION:
*
* XDmaChannel_SgStart
*
* DESCRIPTION:
*
* This function starts a scatter gather operation for a scatter gather
* DMA channel.  The first buffer descriptor in the buffer descriptor list
* will be started with the scatter gather operation.  A scatter gather list
* should have previously been created for the DMA channel and buffer
* descriptors put into the scatter gather list such that there are scatter
* operations ready to be performed.
*
* ARGUMENTS:
*
* InstancePtr contains a pointer to the DMA channel to operate on.  The DMA
* channel should be configured to use scatter gather in order for this function
* to be called.
*
* RETURN VALUE:
*
* A status containing XST_SUCCESS if scatter gather was started successfully
* for the DMA channel.
*
* A value of XST_DMA_SG_NO_LIST indicates the scatter gather list has not
* been created.
*
* A value of XST_DMA_SG_LIST_EMPTY indicates scatter gather was not started
* because the scatter gather list of the DMA channel does not contain any
* buffer descriptors that are ready to be processed by the hardware.
*
* A value of XST_DMA_SG_IS_STARTED indicates scatter gather was not started
* because the scatter gather was not stopped, but was already started.
*
* A value of XST_DMA_SG_BD_NOT_COMMITTED indicates the buffer descriptor of
* scatter gather list which was to be started is not committed to the list.
* This status is more likely if this function is being called from an ISR
* and non-ISR processing is putting descriptors into the list.
*
* A value of XST_DMA_SG_NO_DATA indicates that the buffer descriptor of the
* scatter gather list which was to be started had already been used by the
* hardware for a DMA transfer that has been completed.
*
* NOTES:
*
* It is the responsibility of the caller to get all the buffer descriptors
* after performing a stop operation and before performing a start operation.
* If buffer descriptors are not retrieved between stop and start operations,
* buffer descriptors may be processed by the hardware more than once.
*
******************************************************************************/
XStatus
XDmaChannel_SgStart(XDmaChannel * InstancePtr)
{
        u32 Register;
        XBufDescriptor *LastDescriptorPtr;

        /* assert to verify input arguments */

        XASSERT_NONVOID(InstancePtr != NULL);
        XASSERT_NONVOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);

        /* if a scatter gather list has not been created yet, return a status */

        if (InstancePtr->TotalDescriptorCount == 0) {
                return XST_DMA_SG_NO_LIST;
        }

        /* if the scatter gather list exists but is empty then return a status */

        if (XDmaChannel_IsSgListEmpty(InstancePtr)) {
                return XST_DMA_SG_LIST_EMPTY;
        }

        /* if scatter gather is busy for the DMA channel, return a status because
         * restarting it could lose data
         */

        Register = XIo_In32(InstancePtr->RegBaseAddress + XDC_DMAS_REG_OFFSET);
        if (Register & XDC_DMASR_SG_BUSY_MASK) {
                return XST_DMA_SG_IS_STARTED;
        }

        /* get the address of the last buffer descriptor which the DMA hardware
         * finished processing
         */
        LastDescriptorPtr =
            (XBufDescriptor *) XIo_In32(InstancePtr->RegBaseAddress +
                                        XDC_BDA_REG_OFFSET);

        /* setup the first buffer descriptor that will be sent when the scatter
         * gather channel is enabled, this is only necessary one time since
         * the BDA register of the channel maintains the last buffer descriptor
         * processed
         */
        if (LastDescriptorPtr == NULL) {
                XIo_Out32(InstancePtr->RegBaseAddress + XDC_BDA_REG_OFFSET,
                          (u32) InstancePtr->GetPtr);
        } else {
                XBufDescriptor *NextDescriptorPtr;

                /* get the next descriptor to be started, if the status indicates it
                 * hasn't already been used by the h/w, then it's OK to start it,
                 * s/w sets the status of each descriptor to busy and then h/w clears
                 * the busy when it is complete
                 */
                NextDescriptorPtr =
                    XBufDescriptor_GetNextPtr(LastDescriptorPtr);

                if ((XBufDescriptor_GetStatus(NextDescriptorPtr) &
                     XDC_DMASR_BUSY_MASK) == 0) {
                        return XST_DMA_SG_NO_DATA;
                }
                /* don't start the DMA SG channel if the descriptor to be processed
                 * by h/w is to be committed by the s/w, this function can be called
                 * such that it interrupts a thread that was putting into the list
                 */
                if (NextDescriptorPtr == InstancePtr->CommitPtr) {
                        return XST_DMA_SG_BD_NOT_COMMITTED;
                }
        }

        /* start the scatter gather operation by clearing the stop bit in the
         * control register and setting the enable bit in the s/w control register,
         * both of these are necessary to cause it to start, right now the order of
         * these statements is important, the software control register should be
         * set 1st.  The other order can cause the CPU to have a loss of sync
         * because it cannot read/write the register while the DMA operation is
         * running
         */

        Register = XIo_In32(InstancePtr->RegBaseAddress + XDC_SWCR_REG_OFFSET);

        XIo_Out32(InstancePtr->RegBaseAddress + XDC_SWCR_REG_OFFSET,
                  Register | XDC_SWCR_SG_ENABLE_MASK);

        Register = XIo_In32(InstancePtr->RegBaseAddress + XDC_DMAC_REG_OFFSET);

        XIo_Out32(InstancePtr->RegBaseAddress + XDC_DMAC_REG_OFFSET,
                  Register & ~XDC_DMACR_SG_DISABLE_MASK);

        /* indicate the DMA channel scatter gather operation was started
         * successfully
         */
        return XST_SUCCESS;
}

/******************************************************************************
*
* FUNCTION:
*
* XDmaChannel_SgStop
*
* DESCRIPTION:
*
* This function stops a scatter gather operation for a scatter gather
* DMA channel. This function starts the process of stopping a scatter
* gather operation that is in progress and waits for the stop to be completed.
* Since it waits for the operation to stopped before returning, this function
* could take an amount of time relative to the size of the DMA scatter gather
* operation which is in progress.  The scatter gather list of the DMA channel
* is not modified by this function such that starting the scatter gather
* channel after stopping it will cause it to resume.  This operation is
* considered to be a graceful stop in that the scatter gather operation
* completes the current buffer descriptor before stopping.
*
* If the interrupt is enabled, an interrupt will be generated when the
* operation is stopped and the caller is responsible for handling the
* interrupt.
*
* ARGUMENTS:
*
* InstancePtr contains a pointer to the DMA channel to operate on.  The DMA
* channel should be configured to use scatter gather in order for this function
* to be called.
*
* BufDescriptorPtr is also a return value which contains a pointer to the
* buffer descriptor which the scatter gather operation completed when it
* was stopped.
*
* RETURN VALUE:
*
* A status containing XST_SUCCESS if scatter gather was stopped successfully
* for the DMA channel.
*
* A value of XST_DMA_SG_IS_STOPPED indicates scatter gather was not stoppped
* because the scatter gather is not started, but was already stopped.
*
* BufDescriptorPtr contains a pointer to the buffer descriptor which was
* completed when the operation was stopped.
*
* NOTES:
*
* This function implements a loop which polls the hardware for an infinite
* amount of time. If the hardware is not operating correctly, this function
* may never return.
*
******************************************************************************/
XStatus
XDmaChannel_SgStop(XDmaChannel * InstancePtr,
                   XBufDescriptor ** BufDescriptorPtr)
{
        u32 Register;

        /* assert to verify input arguments */

        XASSERT_NONVOID(InstancePtr != NULL);
        XASSERT_NONVOID(BufDescriptorPtr != NULL);
        XASSERT_NONVOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);

        /* get the contents of the software control register, if scatter gather is not
         * enabled (started), then return a status because the disable acknowledge
         * would not be generated
         */
        Register = XIo_In32(InstancePtr->RegBaseAddress + XDC_SWCR_REG_OFFSET);

        if ((Register & XDC_SWCR_SG_ENABLE_MASK) == 0) {
                return XST_DMA_SG_IS_STOPPED;
        }

        /* Ensure the interrupt status for the scatter gather is cleared such
         * that this function will wait til the disable has occurred, writing
         * a 1 to only that bit in the register will clear only it
         */
        XIo_Out32(InstancePtr->RegBaseAddress + XDC_IS_REG_OFFSET,
                  XDC_IXR_SG_DISABLE_ACK_MASK);

        /* disable scatter gather by writing to the software control register
         * without modifying any other bits of the register
         */
        XIo_Out32(InstancePtr->RegBaseAddress + XDC_SWCR_REG_OFFSET,
                  Register & ~XDC_SWCR_SG_ENABLE_MASK);

        /* scatter gather does not disable immediately, but after the current
         * buffer descriptor is complete, so wait for the DMA channel to indicate
         * the disable is complete
         */
        do {
                Register =
                    XIo_In32(InstancePtr->RegBaseAddress + XDC_IS_REG_OFFSET);
        } while ((Register & XDC_IXR_SG_DISABLE_ACK_MASK) == 0);

        /* Ensure the interrupt status for the scatter gather disable is cleared,
         * writing a 1 to only that bit in the register will clear only it
         */
        XIo_Out32(InstancePtr->RegBaseAddress + XDC_IS_REG_OFFSET,
                  XDC_IXR_SG_DISABLE_ACK_MASK);

        /* set the specified buffer descriptor pointer to point to the buffer
         * descriptor that the scatter gather DMA channel was processing
         */
        *BufDescriptorPtr =
            (XBufDescriptor *) XIo_In32(InstancePtr->RegBaseAddress +
                                        XDC_BDA_REG_OFFSET);

        return XST_SUCCESS;
}

/******************************************************************************
*
* FUNCTION:
*
* XDmaChannel_CreateSgList
*
* DESCRIPTION:
*
* This function creates a scatter gather list in the DMA channel.  A scatter
* gather list consists of a list of buffer descriptors that are available to
* be used for scatter gather operations.  Buffer descriptors are put into the
* list to request a scatter gather operation to be performed.
*
* A number of buffer descriptors are created from the specified memory and put
* into a buffer descriptor list as empty buffer descriptors. This function must
* be called before non-empty buffer descriptors may be put into the DMA channel
* to request scatter gather operations.
*
* ARGUMENTS:
*
* InstancePtr contains a pointer to the DMA channel to operate on.  The DMA
* channel should be configured to use scatter gather in order for this function
* to be called.
*
* MemoryPtr contains a pointer to the memory which is to be used for buffer
* descriptors and must not be cached.
*
* ByteCount contains the number of bytes for the specified memory to be used
* for buffer descriptors.
*
* RETURN VALUE:
*
* A status contains XST_SUCCESS if the scatter gather list was successfully
* created.
*
* A value of XST_DMA_SG_LIST_EXISTS indicates that the scatter gather list
* was not created because the list has already been created.
*
* NOTES:
*
* None.
*
******************************************************************************/
XStatus
XDmaChannel_CreateSgList(XDmaChannel * InstancePtr,
                         u32 * MemoryPtr, u32 ByteCount)
{
        XBufDescriptor *BufferDescriptorPtr = (XBufDescriptor *) MemoryPtr;
        XBufDescriptor *PreviousDescriptorPtr = NULL;
        XBufDescriptor *StartOfListPtr = BufferDescriptorPtr;
        u32 UsedByteCount;

        /* assert to verify valid input arguments, alignment for those
         * arguments that have alignment restrictions, and at least enough
         * memory for one buffer descriptor
         */
        XASSERT_NONVOID(InstancePtr != NULL);
        XASSERT_NONVOID(MemoryPtr != NULL);
        XASSERT_NONVOID(((u32) MemoryPtr & 3) == 0);
        XASSERT_NONVOID(ByteCount != 0);
        XASSERT_NONVOID(ByteCount >= sizeof (XBufDescriptor));
        XASSERT_NONVOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);

        /* if the scatter gather list has already been created, then return
         * with a status
         */
        if (InstancePtr->TotalDescriptorCount != 0) {
                return XST_DMA_SG_LIST_EXISTS;
        }

        /* loop thru the specified memory block and create as many buffer
         * descriptors as possible putting each into the list which is
         * implemented as a ring buffer, make sure not to use any memory which
         * is not large enough for a complete buffer descriptor
         */
        UsedByteCount = 0;
        while ((UsedByteCount + sizeof (XBufDescriptor)) <= ByteCount) {
                /* setup a pointer to the next buffer descriptor in the memory and
                 * update # of used bytes to know when all of memory is used
                 */
                BufferDescriptorPtr = (XBufDescriptor *) ((u32) MemoryPtr +
                                                          UsedByteCount);

                /* initialize the new buffer descriptor such that it doesn't contain
                 * garbage which could be used by the DMA hardware
                 */
                XBufDescriptor_Initialize(BufferDescriptorPtr);

                /* if this is not the first buffer descriptor to be created,
                 * then link it to the last created buffer descriptor
                 */
                if (PreviousDescriptorPtr != NULL) {
                        XBufDescriptor_SetNextPtr(PreviousDescriptorPtr,
                                                  BufferDescriptorPtr);
                }

                /* always keep a pointer to the last created buffer descriptor such
                 * that they can be linked together in the ring buffer
                 */
                PreviousDescriptorPtr = BufferDescriptorPtr;

                /* keep a count of the number of descriptors in the list to allow
                 * error processing to be performed
                 */
                InstancePtr->TotalDescriptorCount++;

                UsedByteCount += sizeof (XBufDescriptor);
        }

        /* connect the last buffer descriptor created and inserted in the list
         * to the first such that a ring buffer is created
         */
        XBufDescriptor_SetNextPtr(BufferDescriptorPtr, StartOfListPtr);

        /* initialize the ring buffer to indicate that there are no
         * buffer descriptors in the list which point to valid data buffers
         */
        InstancePtr->PutPtr = BufferDescriptorPtr;
        InstancePtr->GetPtr = BufferDescriptorPtr;
        InstancePtr->CommitPtr = NULL;
        InstancePtr->LastPtr = BufferDescriptorPtr;
        InstancePtr->ActiveDescriptorCount = 0;

        /* indicate the scatter gather list was successfully created */

        return XST_SUCCESS;
}

/******************************************************************************
*
* FUNCTION:
*
* XDmaChannel_IsSgListEmpty
*
* DESCRIPTION:
*
* This function determines if the scatter gather list of a DMA channel is
* empty with regard to buffer descriptors which are pointing to buffers to be
* used for scatter gather operations.
*
* ARGUMENTS:
*
* InstancePtr contains a pointer to the DMA channel to operate on.  The DMA
* channel should be configured to use scatter gather in order for this function
* to be called.
*
* RETURN VALUE:
*
* A value of TRUE if the scatter gather list is empty, otherwise a value of
* FALSE.
*
* NOTES:
*
* None.
*
******************************************************************************/
u32
XDmaChannel_IsSgListEmpty(XDmaChannel * InstancePtr)
{
        /* assert to verify valid input arguments */

        XASSERT_NONVOID(InstancePtr != NULL);
        XASSERT_NONVOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);

        /* if the number of descriptors which are being used in the list is zero
         * then the list is empty
         */
        return (InstancePtr->ActiveDescriptorCount == 0);
}

/******************************************************************************
*
* FUNCTION:
*
* XDmaChannel_PutDescriptor
*
* DESCRIPTION:
*
* This function puts a buffer descriptor into the DMA channel scatter
* gather list. A DMA channel maintains a list of buffer descriptors which are
* to be processed.  This function puts the specified buffer descriptor
* at the next location in the list.  Note that since the list is already intact,
* the information in the parameter is copied into the list (rather than modify
* list pointers on the fly).
*
* After buffer descriptors are put into the list, they must also be committed
* by calling another function.  This allows multiple buffer descriptors which
* span a single packet to be put into the list while preventing the hardware
* from starting the first buffer descriptor of the packet.
*
* ARGUMENTS:
*
* InstancePtr contains a pointer to the DMA channel to operate on.  The DMA
* channel should be configured to use scatter gather in order for this function
* to be called.
*
* BufferDescriptorPtr is a pointer to the buffer descriptor to be put into
* the next available location of the scatter gather list.
*
* RETURN VALUE:
*
* A status which indicates XST_SUCCESS if the buffer descriptor was
* successfully put into the scatter gather list.
*
* A value of XST_DMA_SG_NO_LIST indicates the scatter gather list has not
* been created.
*
* A value of XST_DMA_SG_LIST_FULL indicates the buffer descriptor was not
* put into the list because the list was full.
*
* A value of XST_DMA_SG_BD_LOCKED indicates the buffer descriptor was not
* put into the list because the buffer descriptor in the list which is to
* be overwritten was locked.  A locked buffer descriptor indicates the higher
* layered software is still using the buffer descriptor.
*
* NOTES:
*
* It is necessary to create a scatter gather list for a DMA channel before
* putting buffer descriptors into it.
*
******************************************************************************/
XStatus
XDmaChannel_PutDescriptor(XDmaChannel * InstancePtr,
                          XBufDescriptor * BufferDescriptorPtr)
{
        u32 Control;

        /* assert to verify valid input arguments and alignment for those
         * arguments that have alignment restrictions
         */
        XASSERT_NONVOID(InstancePtr != NULL);
        XASSERT_NONVOID(BufferDescriptorPtr != NULL);
        XASSERT_NONVOID(((u32) BufferDescriptorPtr & 3) == 0);
        XASSERT_NONVOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);

        /* if a scatter gather list has not been created yet, return a status */

        if (InstancePtr->TotalDescriptorCount == 0) {
                return XST_DMA_SG_NO_LIST;
        }

        /* if the list is full because all descriptors are pointing to valid
         * buffers, then indicate an error, this code assumes no list or an
         * empty list is detected above
         */
        if (InstancePtr->ActiveDescriptorCount ==
            InstancePtr->TotalDescriptorCount) {
                return XST_DMA_SG_LIST_FULL;
        }

        /* if the buffer descriptor in the list which is to be overwritten is
         * locked, then don't overwrite it and return a status
         */
        if (XBufDescriptor_IsLocked(InstancePtr->PutPtr)) {
                return XST_DMA_SG_BD_LOCKED;
        }

        /* set the scatter gather stop bit in the control word of the descriptor
         * to cause the h/w to stop after it processes this descriptor since it
         * will be the last in the list
         */
        Control = XBufDescriptor_GetControl(BufferDescriptorPtr);
        XBufDescriptor_SetControl(BufferDescriptorPtr,
                                  Control | XDC_DMACR_SG_DISABLE_MASK);

        /* set both statuses in the descriptor so we tell if they are updated with
         * the status of the transfer, the hardware should change the busy in the
         * DMA status to be false when it completes
         */
        XBufDescriptor_SetStatus(BufferDescriptorPtr, XDC_DMASR_BUSY_MASK);
        XBufDescriptor_SetDeviceStatus(BufferDescriptorPtr, 0);

        /* copy the descriptor into the next position in the list so it's ready to
         * be used by the h/w, this assumes the descriptor in the list prior to this
         * one still has the stop bit in the control word set such that the h/w
         * use this one yet
         */
        CopyBufferDescriptor(BufferDescriptorPtr, InstancePtr->PutPtr);

        /* only the last in the list and the one to be committed have scatter gather
         * disabled in the control word, a commit requires only one descriptor
         * to be changed, when # of descriptors to commit > 2 all others except the
         * 1st and last have scatter gather enabled
         */
        if ((InstancePtr->CommitPtr != InstancePtr->LastPtr) &&
            (InstancePtr->CommitPtr != NULL)) {
                Control = XBufDescriptor_GetControl(InstancePtr->LastPtr);
                XBufDescriptor_SetControl(InstancePtr->LastPtr,
                                          Control & ~XDC_DMACR_SG_DISABLE_MASK);
        }

        /* update the list data based upon putting a descriptor into the list,
         * these operations must be last
         */
        InstancePtr->ActiveDescriptorCount++;

        /* only update the commit pointer if it is not already active, this allows
         * it to be deactivated after every commit such that a single descriptor
         * which is committed does not appear to be waiting to be committed
         */
        if (InstancePtr->CommitPtr == NULL) {
                InstancePtr->CommitPtr = InstancePtr->LastPtr;
        }

        /* these updates MUST BE LAST after the commit pointer update in order for
         * the commit pointer to track the correct descriptor to be committed
         */
        InstancePtr->LastPtr = InstancePtr->PutPtr;
        InstancePtr->PutPtr = XBufDescriptor_GetNextPtr(InstancePtr->PutPtr);

        return XST_SUCCESS;
}

/******************************************************************************
*
* FUNCTION:
*
* XDmaChannel_CommitPuts
*
* DESCRIPTION:
*
* This function commits the buffer descriptors which have been put into the
* scatter list for the DMA channel since the last commit operation was
* performed.  This enables the calling functions to put several buffer
* descriptors into the list (e.g.,a packet's worth) before allowing the scatter
* gather operations to start.  This prevents the DMA channel hardware from
* starting to use the buffer descriptors in the list before they are ready
* to be used (multiple buffer descriptors for a single packet).
*
* ARGUMENTS:
*
* InstancePtr contains a pointer to the DMA channel to operate on.  The DMA
* channel should be configured to use scatter gather in order for this function
* to be called.
*
* RETURN VALUE:
*
* A status indicating XST_SUCCESS if the buffer descriptors of the list were
* successfully committed.
*
* A value of XST_DMA_SG_NOTHING_TO_COMMIT indicates that the buffer descriptors
* were not committed because there was nothing to commit in the list.  All the
* buffer descriptors which are in the list are commited.
*
* NOTES:
*
* None.
*
******************************************************************************/
XStatus
XDmaChannel_CommitPuts(XDmaChannel * InstancePtr)
{
        /* assert to verify input arguments */

        XASSERT_NONVOID(InstancePtr != NULL);
        XASSERT_NONVOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);

        /* if the buffer descriptor to be committed is already committed or
         * the list is empty (none have been put in), then indicate an error
         */
        if ((InstancePtr->CommitPtr == NULL) ||
            XDmaChannel_IsSgListEmpty(InstancePtr)) {
                return XST_DMA_SG_NOTHING_TO_COMMIT;
        }

        /* last descriptor in the list must have scatter gather disabled so the end
         * of the list is hit by h/w, if descriptor to commit is not last in list,
         * commit descriptors by enabling scatter gather in the descriptor
         */
        if (InstancePtr->CommitPtr != InstancePtr->LastPtr) {
                u32 Control;

                Control = XBufDescriptor_GetControl(InstancePtr->CommitPtr);
                XBufDescriptor_SetControl(InstancePtr->CommitPtr, Control &
                                          ~XDC_DMACR_SG_DISABLE_MASK);
        }
        /* Update the commit pointer to indicate that there is nothing to be
         * committed, this state is used by start processing to know that the
         * buffer descriptor to start is not waiting to be committed
         */
        InstancePtr->CommitPtr = NULL;

        return XST_SUCCESS;
}

/******************************************************************************
*
* FUNCTION:
*
* XDmaChannel_GetDescriptor
*
* DESCRIPTION:
*
* This function gets a buffer descriptor from the scatter gather list of the
* DMA channel. The buffer descriptor is retrieved from the scatter gather list
* and the scatter gather list is updated to not include the retrieved buffer
* descriptor.  This is typically done after a scatter gather operation
* completes indicating that a data buffer has been successfully sent or data
* has been received into the data buffer. The purpose of this function is to
* allow the device using the scatter gather operation to get the results of the
* operation.
*
* ARGUMENTS:
*
* InstancePtr contains a pointer to the DMA channel to operate on.  The DMA
* channel should be configured to use scatter gather in order for this function
* to be called.
*
* BufDescriptorPtr is a pointer to a pointer to the buffer descriptor which
* was retrieved from the list.  The buffer descriptor is not really removed
* from the list, but it is changed to a state such that the hardware will not
* use it again until it is put into the scatter gather list of the DMA channel.
*
* RETURN VALUE:
*
* A status indicating XST_SUCCESS if a buffer descriptor was retrieved from
* the scatter gather list of the DMA channel.
*
* A value of XST_DMA_SG_NO_LIST indicates the scatter gather list has not
* been created.
*
* A value of XST_DMA_SG_LIST_EMPTY indicates no buffer descriptor was
* retrieved from the list because there are no buffer descriptors to be
* processed in the list.
*
* BufDescriptorPtr is updated to point to the buffer descriptor which was
* retrieved from the list if the status indicates success.
*
* NOTES:
*
* None.
*
******************************************************************************/
XStatus
XDmaChannel_GetDescriptor(XDmaChannel * InstancePtr,
                          XBufDescriptor ** BufDescriptorPtr)
{
        u32 Control;

        /* assert to verify input arguments */

        XASSERT_NONVOID(InstancePtr != NULL);
        XASSERT_NONVOID(BufDescriptorPtr != NULL);
        XASSERT_NONVOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);

        /* if a scatter gather list has not been created yet, return a status */

        if (InstancePtr->TotalDescriptorCount == 0) {
                return XST_DMA_SG_NO_LIST;
        }

        /* if the buffer descriptor list is empty, then indicate an error */

        if (XDmaChannel_IsSgListEmpty(InstancePtr)) {
                return XST_DMA_SG_LIST_EMPTY;
        }

        /* retrieve the next buffer descriptor which is ready to be processed from
         * the buffer descriptor list for the DMA channel, set the control word
         * such that hardware will stop after the descriptor has been processed
         */
        Control = XBufDescriptor_GetControl(InstancePtr->GetPtr);
        XBufDescriptor_SetControl(InstancePtr->GetPtr,
                                  Control | XDC_DMACR_SG_DISABLE_MASK);

        /* set the input argument, which is also an output, to point to the
         * buffer descriptor which is to be retrieved from the list
         */
        *BufDescriptorPtr = InstancePtr->GetPtr;

        /* update the pointer of the DMA channel to reflect the buffer descriptor
         * was retrieved from the list by setting it to the next buffer descriptor
         * in the list and indicate one less descriptor in the list now
         */
        InstancePtr->GetPtr = XBufDescriptor_GetNextPtr(InstancePtr->GetPtr);
        InstancePtr->ActiveDescriptorCount--;

        return XST_SUCCESS;
}

/*********************** Interrupt Collescing Functions **********************/

/******************************************************************************
*
* FUNCTION:
*
* XDmaChannel_GetPktCount
*
* DESCRIPTION:
*
* This function returns the value of the unserviced packet count register of
* the DMA channel.  This count represents the number of packets that have been
* sent or received by the hardware, but not processed by software.
*
* ARGUMENTS:
*
* InstancePtr contains a pointer to the DMA channel to operate on.  The DMA
* channel should be configured to use scatter gather in order for this function
* to be called.
*
* RETURN VALUE:
*
* The unserviced packet counter register contents for the DMA channel.
*
* NOTES:
*
* None.
*
******************************************************************************/
u32
XDmaChannel_GetPktCount(XDmaChannel * InstancePtr)
{
        /* assert to verify input arguments */

        XASSERT_NONVOID(InstancePtr != NULL);
        XASSERT_NONVOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);

        /* get the unserviced packet count from the register and return it */

        return XIo_In32(InstancePtr->RegBaseAddress + XDC_UPC_REG_OFFSET);
}

/******************************************************************************
*
* FUNCTION:
*
* XDmaChannel_DecrementPktCount
*
* DESCRIPTION:
*
* This function decrements the value of the unserviced packet count register.
* This informs the hardware that the software has processed a packet.  The
* unserviced packet count register may only be decremented by one in the
* hardware.
*
* ARGUMENTS:
*
* InstancePtr contains a pointer to the DMA channel to operate on.  The DMA
* channel should be configured to use scatter gather in order for this function
* to be called.
*
* RETURN VALUE:
*
* None.
*
* NOTES:
*
* None.
*
******************************************************************************/
void
XDmaChannel_DecrementPktCount(XDmaChannel * InstancePtr)
{
        u32 Register;

        /* assert to verify input arguments */

        XASSERT_VOID(InstancePtr != NULL);
        XASSERT_VOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);

        /* if the unserviced packet count register can be decremented (rather
         * than rolling over) decrement it by writing a 1 to the register,
         * this is the only valid write to the register as it serves as an
         * acknowledge that a packet was handled by the software
         */
        Register = XIo_In32(InstancePtr->RegBaseAddress + XDC_UPC_REG_OFFSET);
        if (Register > 0) {
                XIo_Out32(InstancePtr->RegBaseAddress + XDC_UPC_REG_OFFSET,
                          1UL);
        }
}

/******************************************************************************
*
* FUNCTION:
*
* XDmaChannel_SetPktThreshold
*
* DESCRIPTION:
*
* This function sets the value of the packet count threshold register of the
* DMA channel.  It reflects the number of packets that must be sent or
* received before generating an interrupt.  This value helps implement
* a concept called "interrupt coalescing", which is used to reduce the number
* of interrupts from devices with high data rates.
*
* ARGUMENTS:
*
* InstancePtr contains a pointer to the DMA channel to operate on.  The DMA
* channel should be configured to use scatter gather in order for this function
* to be called.
*
* Threshold is the value that is written to the threshold register of the
* DMA channel.
*
* RETURN VALUE:
*
* A status containing XST_SUCCESS if the packet count threshold was
* successfully set.
*
* NOTES:
*
* The packet threshold could be set to larger than the number of descriptors
* allocated to the DMA channel. In this case, the wait bound will take over
* and always indicate data arrival. There was a check in this function that
* returned an error if the treshold was larger than the number of descriptors,
* but that was removed because users would then have to set the threshold
* only after they set descriptor space, which is an order dependency that
* caused confustion.
*
******************************************************************************/
XStatus
XDmaChannel_SetPktThreshold(XDmaChannel * InstancePtr, u8 Threshold)
{
        /* assert to verify input arguments, don't assert the threshold since
         * it's range is unknown
         */
        XASSERT_NONVOID(InstancePtr != NULL);
        XASSERT_NONVOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);

        /* set the packet count threshold in the register such that an interrupt
         * may be generated, if enabled, when the packet count threshold is
         * reached or exceeded
         */
        XIo_Out32(InstancePtr->RegBaseAddress + XDC_PCT_REG_OFFSET,
                  (u32) Threshold);

        /* indicate the packet count threshold was successfully set */

        return XST_SUCCESS;
}

/******************************************************************************
*
* FUNCTION:
*
* XDmaChannel_GetPktThreshold
*
* DESCRIPTION:
*
* This function gets the value of the packet count threshold register of the
* DMA channel.  This value reflects the number of packets that must be sent or
* received before generating an interrupt.  This value helps implement a concept
* called "interrupt coalescing", which is used to reduce the number of
* interrupts from devices with high data rates.
*
* ARGUMENTS:
*
* InstancePtr contains a pointer to the DMA channel to operate on.  The DMA
* channel should be configured to use scatter gather in order for this function
* to be called.
*
* RETURN VALUE:
*
* The packet threshold register contents for the DMA channel and is a value in
* the range 0 - 1023.  A value of 0 indicates the packet wait bound timer is
* disabled.
*
* NOTES:
*
* None.
*
******************************************************************************/
u8
XDmaChannel_GetPktThreshold(XDmaChannel * InstancePtr)
{
        /* assert to verify input arguments */

        XASSERT_NONVOID(InstancePtr != NULL);
        XASSERT_NONVOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);

        /* get the packet count threshold from the register and return it,
         * since only 8 bits are used, cast it to return only those bits */

        return (u8) XIo_In32(InstancePtr->RegBaseAddress + XDC_PCT_REG_OFFSET);
}

/******************************************************************************
*
* FUNCTION:
*
* XDmaChannel_SetPktWaitBound
*
* DESCRIPTION:
*
* This function sets the value of the packet wait bound register of the
* DMA channel.  This value reflects the timer value used to trigger an
* interrupt when not enough packets have been received to reach the packet
* count threshold.
*
* The timer is in millisecond units with +/- 33% accuracy.
*
* ARGUMENTS:
*
* InstancePtr contains a pointer to the DMA channel to operate on.  The DMA
* channel should be configured to use scatter gather in order for this function
* to be called.
*
* WaitBound is the value, in milliseconds, to be stored in the wait bound
* register of the DMA channel and is a value in the range 0  - 1023.  A value
* of 0 disables the packet wait bound timer.
*
* RETURN VALUE:
*
* None.
*
* NOTES:
*
* None.
*
******************************************************************************/
void
XDmaChannel_SetPktWaitBound(XDmaChannel * InstancePtr, u32 WaitBound)
{
        /* assert to verify input arguments */

        XASSERT_VOID(InstancePtr != NULL);
        XASSERT_VOID(WaitBound < 1024);
        XASSERT_VOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);

        /* set the packet wait bound in the register such that interrupt may be
         * generated, if enabled, when packets have not been handled for a specific
         * amount of time
         */
        XIo_Out32(InstancePtr->RegBaseAddress + XDC_PWB_REG_OFFSET, WaitBound);
}

/******************************************************************************
*
* FUNCTION:
*
* XDmaChannel_GetPktWaitBound
*
* DESCRIPTION:
*
* This function gets the value of the packet wait bound register of the
* DMA channel.  This value contains the timer value used to trigger an
* interrupt when not enough packets have been received to reach the packet
* count threshold.
*
* The timer is in millisecond units with +/- 33% accuracy.
*
* ARGUMENTS:
*
* InstancePtr contains a pointer to the DMA channel to operate on.  The DMA
* channel should be configured to use scatter gather in order for this function
* to be called.
*
* RETURN VALUE:
*
* The packet wait bound register contents for the DMA channel.
*
* NOTES:
*
* None.
*
******************************************************************************/
u32
XDmaChannel_GetPktWaitBound(XDmaChannel * InstancePtr)
{
        /* assert to verify input arguments */

        XASSERT_NONVOID(InstancePtr != NULL);
        XASSERT_NONVOID(InstancePtr->IsReady == XCOMPONENT_IS_READY);

        /* get the packet wait bound from the register and return it */

        return XIo_In32(InstancePtr->RegBaseAddress + XDC_PWB_REG_OFFSET);
}