/* Cypress West Bridge API source file (cyasdma.c)

## ===========================

##

##  Copyright Cypress Semiconductor Corporation, 2006-2009,

##  All Rights Reserved

##  UNPUBLISHED, LICENSED SOFTWARE.

##

##  CONFIDENTIAL AND PROPRIETARY INFORMATION

##  WHICH IS THE PROPERTY OF CYPRESS.

##

##  Use of this file is governed

##  by the license agreement included in the file

##

##     <install>/license/license.txt

##

##  where <install> is the Cypress software

##  installation root directory path.

##

## ===========================

*/

#include "cyashal.h"

#include "cyasdma.h"

#include "cyaslowlevel.h"

#include "cyaserr.h"

#include "cyasregs.h"

/*

 * Add the DMA queue entry to the free list to be re-used later

 */

static void

CyAsDmaAddRequestToFreeQueue(CyAsDevice *dev_p, CyAsDmaQueueEntry *req_p)

{

    uint32_t imask ;

    imask = CyAsHalDisableInterrupts() ;

    req_p->next_p = dev_p->dma_freelist_p ;

    dev_p->dma_freelist_p = req_p ;

    CyAsHalEnableInterrupts(imask) ;

}

/*

 * Get a DMA queue entry from the free list.

 */

static CyAsDmaQueueEntry *

CyAsDmaGetDmaQueueEntry(CyAsDevice *dev_p)

{

    CyAsDmaQueueEntry *req_p ;

    uint32_t imask ;

    CyAsHalAssert(dev_p->dma_freelist_p != 0) ;

    imask = CyAsHalDisableInterrupts() ;

    req_p = dev_p->dma_freelist_p ;

    dev_p->dma_freelist_p = req_p->next_p ;

    CyAsHalEnableInterrupts(imask) ;

    return req_p ;

}

/*

 * Set the maximum size that the West Bridge hardware can handle in a single DMA operation.  This size

 * may change for the P <-> U endpoints as a function of the endpoint type and whether we are running

 * at full speed or high speed.

 */

CyAsReturnStatus_t

CyAsDmaSetMaxDmaSize(CyAsDevice *dev_p, CyAsEndPointNumber_t ep, uint32_t size)

{

    /* In MTP mode, EP2 is allowed to have all max sizes. */

    if ((!dev_p->is_mtp_firmware) || (ep != 0x02))

    {

        if (size < 64 || size > 1024)

            return CY_AS_ERROR_INVALID_SIZE ;

    }

    CY_AS_NUM_EP(dev_p, ep)->maxhwdata = (uint16_t)size ;

    return CY_AS_ERROR_SUCCESS ;

}

/*

 * The callback for requests sent to West Bridge to relay endpoint data.  Endpoint

 * data for EP0 and EP1 are sent using mailbox requests.  This is the callback that

 * is called when a response to a mailbox request to send data is received.

 */

static void

CyAsDmaRequestCallback(

    CyAsDevice *dev_p,

    uint8_t context,

    CyAsLLRequestResponse *req_p,

    CyAsLLRequestResponse *resp_p,

    CyAsReturnStatus_t ret)

{

    uint16_t v ;

    uint16_t datacnt ;

    CyAsEndPointNumber_t ep ;

    (void)context ;

    CyAsLogDebugMessage(5, "CyAsDmaRequestCallback called") ;

    /*

     * Extract the return code from the firmware

     */

    if (ret == CY_AS_ERROR_SUCCESS)

    {

        if (CyAsLLRequestResponse_GetCode(resp_p) != CY_RESP_SUCCESS_FAILURE)

            ret = CY_AS_ERROR_INVALID_RESPONSE ;

        else

            ret = CyAsLLRequestResponse_GetWord(resp_p, 0) ;

    }

    /*

     * Extract the endpoint number and the transferred byte count

     * from the request.

     */

    v = CyAsLLRequestResponse_GetWord(req_p, 0) ;

    ep = (CyAsEndPointNumber_t)((v >> 13) & 0x01) ;

    if (ret == CY_AS_ERROR_SUCCESS)

    {

        /*

         * If the firmware returns success, all of the data requested was

         * transferred.  There are no partial transfers.

         */

        datacnt = v & 0x3FF ;

    }

    else

    {

        /*

         * If the firmware returned an error, no data was transferred.

         */

        datacnt = 0 ;

    }

    /*

     * Queue the request and response data structures for use with the

     * next EP0 or EP1 request.

     */

    if (ep == 0)

    {

        dev_p->usb_ep0_dma_req = req_p ;

        dev_p->usb_ep0_dma_resp = resp_p ;

    }

    else

    {

        dev_p->usb_ep1_dma_req = req_p ;

        dev_p->usb_ep1_dma_resp = resp_p ;

    }

    /*

     * Call the DMA complete function so we can signal that this portion of the

     * transfer has completed.  If the low level request was canceled, we do not

     * need to signal the completed function as the only way a cancel can happen

     * is via the DMA cancel function.

     */

    if (ret != CY_AS_ERROR_CANCELED)

        CyAsDmaCompletedCallback(dev_p->tag, ep, datacnt, ret) ;

}

/*

 * Set the DRQ mask register for the given endpoint number.  If state is

 * CyTrue, the DRQ interrupt for the given endpoint is enabled, otherwise

 * it is disabled.

 */

static void

CyAsDmaSetDrq(CyAsDevice *dev_p, CyAsEndPointNumber_t ep, CyBool state)

{

    uint16_t mask ;

    uint16_t v ;

    uint32_t intval ;

    /*

     * There are not DRQ register bits for EP0 and EP1

     */

    if (ep == 0 || ep == 1)

        return ;

    /*

     * Disable interrupts while we do this to be sure the state of the

     * DRQ mask register is always well defined.

     */

    intval = CyAsHalDisableInterrupts() ;

    /*

     * Set the DRQ bit to the given state for the ep given

     */

    mask = (1 << ep) ;

    v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_P0_DRQ_MASK) ;

    if (state)

        v |= mask ;

    else

        v &= ~mask ;

    CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_P0_DRQ_MASK, v) ;

    CyAsHalEnableInterrupts(intval) ;

}

/*

* Send the next DMA request for the endpoint given

*/

static void

CyAsDmaSendNextDmaRequest(CyAsDevice *dev_p, CyAsDmaEndPoint *ep_p)

{

    uint32_t datacnt ;

    void *buf_p ;

    CyAsDmaQueueEntry *dma_p ;

    CyAsLogDebugMessage(6, "CyAsDmaSendNextDmaRequest called") ;

    /* If the queue is empty, nothing to do */

    dma_p = ep_p->queue_p ;

    if (dma_p == 0)

    {

        /*

         * There are not pending DMA requests for this endpoint.  Disable

         * the DRQ mask bits to insure no interrupts will be triggered by this

         * endpoint until someone is interested in the data.

         */

        CyAsDmaSetDrq(dev_p, ep_p->ep, CyFalse) ;

        return ;

    }

    CyAsDmaEndPointSetRunning(ep_p) ;

    /*

     * Get the number of words that still need to be xferred in

     * this request.

     */

    datacnt = dma_p->size - dma_p->offset ;

    CyAsHalAssert(datacnt >= 0) ;

    /*

     * The HAL layer should never limit the size of the transfer to

     * something less than the maxhwdata otherwise, the data will be

     * sent in packets that are not correct in size.

     */

    CyAsHalAssert(ep_p->maxhaldata == CY_AS_DMA_MAX_SIZE_HW_SIZE || ep_p->maxhaldata >= ep_p->maxhwdata) ;

    /*

     * Update the number of words that need to be xferred yet

     * based on the limits of the HAL layer.

     */

    if (ep_p->maxhaldata == CY_AS_DMA_MAX_SIZE_HW_SIZE)

    {

        if (datacnt > ep_p->maxhwdata)

            datacnt = ep_p->maxhwdata ;

    }

    else

    {

        if (datacnt > ep_p->maxhaldata)

            datacnt = ep_p->maxhaldata ;

    }

    /*

     * Find a pointer to the data that needs to be transferred

     */

    buf_p = (((char *)dma_p->buf_p) + dma_p->offset);

    /*

     * Mark a request in transit

     */

    CyAsDmaEndPointSetInTransit(ep_p) ;

    if (ep_p->ep == 0 || ep_p->ep == 1)

    {

        /*

         * If this is a WRITE request on EP0 and EP1, we write the data via an EP_DATA request

         * to West Bridge via the mailbox registers.  If this is a READ request, we do nothing and the data will

         * arrive via an EP_DATA request from West Bridge.  In the request handler for the USB context we will pass

         * the data back into the DMA module.

         */

        if (dma_p->readreq == CyFalse)

        {

            uint16_t v ;

            uint16_t len ;

            CyAsLLRequestResponse *resp_p ;

            CyAsLLRequestResponse *req_p ;

            CyAsReturnStatus_t ret ;

            len = (uint16_t)(datacnt / 2) ;

            if (datacnt % 2)

                len++ ;

            len++ ;

            if (ep_p->ep == 0)

            {

                req_p = dev_p->usb_ep0_dma_req ;

                resp_p = dev_p->usb_ep0_dma_resp ;

                dev_p->usb_ep0_dma_req = 0 ;

                dev_p->usb_ep0_dma_resp = 0 ;

            }

            else

            {

                req_p = dev_p->usb_ep1_dma_req ;

                resp_p = dev_p->usb_ep1_dma_resp ;

                dev_p->usb_ep1_dma_req = 0 ;

                dev_p->usb_ep1_dma_resp = 0 ;

            }

            CyAsHalAssert(req_p != 0) ;

            CyAsHalAssert(resp_p != 0) ;

            CyAsHalAssert(len <= 64) ;

            CyAsLLInitRequest(req_p, CY_RQT_USB_EP_DATA, CY_RQT_USB_RQT_CONTEXT, len) ;

            v = (uint16_t)(datacnt | (ep_p->ep << 13) | (1 << 14)) ;

            if (dma_p->offset == 0)

                v |= (1 << 12) ;            /* Set the first packet bit */

            if (dma_p->offset + datacnt == dma_p->size)

                v |= (1 << 11) ;            /* Set the last packet bit */

            CyAsLLRequestResponse_SetWord(req_p, 0, v) ;

            CyAsLLRequestResponse_Pack(req_p, 1, datacnt, buf_p) ;

            CyAsLLInitResponse(resp_p, 1) ;

            ret = CyAsLLSendRequest(dev_p, req_p, resp_p, CyFalse, CyAsDmaRequestCallback) ;

            if (ret == CY_AS_ERROR_SUCCESS)

                CyAsLogDebugMessage(5, "+++ Send EP 0/1 data via mailbox registers") ;

            else

                CyAsLogDebugMessage(5, "+++ Error Sending EP 0/1 data via mailbox registers - CY_AS_ERROR_TIMEOUT") ;

            if (ret != CY_AS_ERROR_SUCCESS)

                CyAsDmaCompletedCallback(dev_p->tag, ep_p->ep, 0, ret) ;

        }

    }

    else

    {

        /*

         * This is a DMA request on an endpoint that is accessible via the P port.  Ask the

         * HAL DMA capabilities to perform this.  The amount of data sent is limited by the

         * HAL max size as well as what we need to send.  If the ep_p->maxhaldata is set to

         * a value larger than the endpoint buffer size, then we will pass more than a single

         * buffer worth of data to the HAL layer and expect the HAL layer to divide the data

         * into packets.  The last parameter here (ep_p->maxhwdata) gives the packet size for

         * the data so the HAL layer knows what the packet size should be.

         */

        if (CyAsDmaEndPointIsDirectionIn(ep_p))

            CyAsHalDmaSetupWrite(dev_p->tag, ep_p->ep, buf_p, datacnt, ep_p->maxhwdata) ;

        else

            CyAsHalDmaSetupRead(dev_p->tag, ep_p->ep, buf_p, datacnt, ep_p->maxhwdata) ;

        /*

         * The DRQ interrupt for this endpoint should be enabled so that the data

         * transfer progresses at interrupt time.

         */

        CyAsDmaSetDrq(dev_p, ep_p->ep, CyTrue) ;

    }

}

/*

 * This function is called when the HAL layer has completed the last requested DMA

 * operation.  This function sends/receives the next batch of data associated with the

 * current DMA request, or it is is complete, moves to the next DMA request.

 */

void

CyAsDmaCompletedCallback(CyAsHalDeviceTag tag, CyAsEndPointNumber_t ep, uint32_t cnt, CyAsReturnStatus_t status)

{

    uint32_t mask ;

    CyAsDmaQueueEntry *req_p ;

    CyAsDmaEndPoint *ep_p ;

    CyAsDevice *dev_p = CyAsDeviceFindFromTag(tag) ;

    /* Make sure the HAL layer gave us good parameters */

    CyAsHalAssert(dev_p != 0) ;

    CyAsHalAssert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE) ;

    CyAsHalAssert(ep < 16) ;

    /* Get the endpoint ptr */

    ep_p = CY_AS_NUM_EP(dev_p, ep) ;

    CyAsHalAssert(ep_p->queue_p != 0) ;

    /* Get a pointer to the current entry in the queue */

    mask = CyAsHalDisableInterrupts() ;

    req_p = ep_p->queue_p ;

    /* Update the offset to reflect the data actually received or sent */

    req_p->offset += cnt ;

    /*

     * If we are still sending/receiving the current packet, send/receive the next chunk

     * Basically we keep going if we have not sent/received enough data, and we are not doing

     * a packet operation, and the last packet sent or received was a full sized packet.  In

     * other words, when we are NOT doing a packet operation, a less than full size packet

     * (a short packet) will terminate the operation.

     *

     * Note: If this is EP1 request and the request has timed out, it means the buffer is not free.

     * We have to resend the data.

     *

     * Note: For the MTP data transfers, the DMA transfer for the next packet can only be started

     * asynchronously, after a firmware event notifies that the device is ready.

     */

    if (((req_p->offset != req_p->size) && (req_p->packet == CyFalse) && ((cnt == ep_p->maxhaldata) ||

                    ((cnt == ep_p->maxhwdata) && ((ep != CY_AS_MTP_READ_ENDPOINT) || (cnt == dev_p->usb_max_tx_size)))))

            || ((ep == 1) && (status == CY_AS_ERROR_TIMEOUT)))

    {

        CyAsHalEnableInterrupts(mask) ;

        /*

         * And send the request again to send the next block of data. Special handling for

         * MTP transfers on EPs 2 and 6. The SendNextRequest will be processed based on the

         * event sent by the firmware.

         */

        if ((ep == CY_AS_MTP_WRITE_ENDPOINT) || (

                    (ep == CY_AS_MTP_READ_ENDPOINT) && (!CyAsDmaEndPointIsDirectionIn (ep_p))))

            CyAsDmaEndPointSetStopped(ep_p) ;

        else

            CyAsDmaSendNextDmaRequest(dev_p, ep_p) ;

    }

    else

    {

        /*

         * We get here if ...

         *    we have sent or received all of the data

         *         or

         *    we are doing a packet operation

         *         or

         *    we receive a short packet

         */

        /*

         * Remove this entry from the DMA queue for this endpoint.

         */

        CyAsDmaEndPointClearInTransit(ep_p) ;

        ep_p->queue_p = req_p->next_p ;

        if (ep_p->last_p == req_p)

        {

            /*

             * We have removed the last packet from the DMA queue, disable the

             * interrupt associated with this interrupt.

             */

            ep_p->last_p = 0 ;

            CyAsHalEnableInterrupts(mask) ;

            CyAsDmaSetDrq(dev_p, ep, CyFalse) ;

        }

        else

            CyAsHalEnableInterrupts(mask) ;

        if (req_p->cb)

        {

            /*

             * If the request has a callback associated with it, call the callback

             * to tell the interested party that this DMA request has completed.

             *

             * Note, we set the InCallback bit to insure that we cannot recursively

             * call an API function that is synchronous only from a callback.

             */

            CyAsDeviceSetInCallback(dev_p) ;

            (*req_p->cb)(dev_p, ep, req_p->buf_p, req_p->offset, status) ;

            CyAsDeviceClearInCallback(dev_p) ;

        }

        /*

         * We are done with this request, put it on the freelist to be

         * reused at a later time.

         */

        CyAsDmaAddRequestToFreeQueue(dev_p, req_p) ;

        if (ep_p->queue_p == 0)

        {

            /*

             * If the endpoint is out of DMA entries, set it the endpoint as

             * stopped.

             */

            CyAsDmaEndPointSetStopped(ep_p) ;

            /*

             * The DMA queue is empty, wake any task waiting on the QUEUE to

             * drain.

             */

            if (CyAsDmaEndPointIsSleeping(ep_p))

            {

                CyAsDmaEndPointSetWakeState(ep_p) ;

                CyAsHalWake(&ep_p->channel) ;

            }

        }

        else

        {

            /*

             * If the queued operation is a MTP transfer, wait until firmware event

             * before sending down the next DMA request.

             */

            if ((ep == CY_AS_MTP_WRITE_ENDPOINT) || (

                        (ep == CY_AS_MTP_READ_ENDPOINT) && (!CyAsDmaEndPointIsDirectionIn (ep_p))))

                CyAsDmaEndPointSetStopped(ep_p) ;

            else

                CyAsDmaSendNextDmaRequest(dev_p, ep_p) ;

        }

    }

}

/*

* This function is used to kick start DMA on a given channel.  If DMA is already running

* on the given endpoint, nothing happens.  If DMA is not running, the first entry is pulled

* from the DMA queue and sent/recevied to/from the West Bridge device.

*/

CyAsReturnStatus_t

CyAsDmaKickStart(CyAsDevice *dev_p, CyAsEndPointNumber_t ep)

{

    CyAsDmaEndPoint *ep_p ;

    CyAsHalAssert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE) ;

    ep_p = CY_AS_NUM_EP(dev_p, ep) ;

    /* We are already running */

    if (CyAsDmaEndPointIsRunning(ep_p))

        return CY_AS_ERROR_SUCCESS ;

    CyAsDmaSendNextDmaRequest(dev_p, ep_p);

    return CY_AS_ERROR_SUCCESS ;

}

/*

 * This function stops the given endpoint.  Stopping and endpoint cancels

 * any pending DMA operations and frees all resources associated with the

 * given endpoint.

 */

static CyAsReturnStatus_t

CyAsDmaStopEndPoint(CyAsDevice *dev_p, CyAsEndPointNumber_t ep)

{

    CyAsReturnStatus_t ret ;

    CyAsDmaEndPoint *ep_p = CY_AS_NUM_EP(dev_p, ep) ;

    /*

     * Cancel any pending DMA requests associated with this endpoint.  This