/* Cypress West Bridge API source file (cyaslowlevel.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 "cyascast.h"

#include "cyasdevice.h"

#include "cyaslowlevel.h"

#include "cyasintr.h"

#include "cyaserr.h"

#include "cyasregs.h"

static const uint32_t CyAsLowLevelTimeoutCount = 65536 * 4 ;

/* Forward declaration */

static CyAsReturnStatus_t CyAsSendOne(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p) ;

/*

* This array holds the size of the largest request we will ever recevie from

* the West Bridge device per context.  The size is in 16 bit words.  Note a size of

* 0xffff indicates that there will be no requests on this context from West Bridge.

*/

static uint16_t MaxRequestLength[CY_RQT_CONTEXT_COUNT] =

{

    8,                          /* CY_RQT_GENERAL_RQT_CONTEXT - CY_RQT_INITIALIZATION_COMPLETE */

    8,                          /* CY_RQT_RESOURCE_RQT_CONTEXT - none */

    8,                          /* CY_RQT_STORAGE_RQT_CONTEXT - CY_RQT_MEDIA_CHANGED */

    128,                        /* CY_RQT_USB_RQT_CONTEXT - CY_RQT_USB_EVENT */

    8                           /* CY_RQT_TUR_RQT_CONTEXT - CY_RQT_TURBO_CMD_FROM_HOST */

} ;

/*

* For the given context, this function removes the request node at the head of the

* queue from the context.  This is called after all processing has occurred on

* the given request and response and we are ready to remove this entry from the

* queue.

*/

static void

CyAsLLRemoveRequestQueueHead(CyAsDevice *dev_p, CyAsContext *ctxt_p)

{

    uint32_t mask, state ;

    CyAsLLRequestListNode *node_p ;

    (void)dev_p ;

    CyAsHalAssert(ctxt_p->request_queue_p != 0) ;

    mask = CyAsHalDisableInterrupts() ;

    node_p = ctxt_p->request_queue_p ;

    ctxt_p->request_queue_p = node_p->next ;

    CyAsHalEnableInterrupts(mask) ;

    node_p->callback = 0 ;

    node_p->rqt = 0 ;

    node_p->resp = 0 ;

    /*

    * Note that the caller allocates and destroys the request and response.  Generally the

    * destroy happens in the callback for async requests and after the wait returns for

    * sync.  The request and response may not actually be destroyed but may be managed in other

    * ways as well.  It is the responsibilty of the caller to deal with these in any case.  The

    * caller can do this in the request/response callback function.

    */

    state = CyAsHalDisableInterrupts() ;

    CyAsHalCBFree(node_p) ;

    CyAsHalEnableInterrupts(state) ;

}

/*

* For the context given, this function sends the next request to

* West Bridge via the mailbox register, if the next request is ready to

* be sent and has not already been sent.

*/

static void

CyAsLLSendNextRequest(CyAsDevice *dev_p, CyAsContext *ctxt_p)

{

    CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

    /*

    * ret == ret is equivalent to while (1) but eliminates compiler warnings for

    * some compilers.

    */

    while (ret == ret)

    {

        CyAsLLRequestListNode *node_p = ctxt_p->request_queue_p ;

        if (node_p == 0)

            break ;

        if (CyAsRequestGetNodeState(node_p) != CY_AS_REQUEST_LIST_STATE_QUEUED)

            break ;

        CyAsRequestSetNodeState(node_p, CY_AS_REQUEST_LIST_STATE_WAITING) ;

        ret = CyAsSendOne(dev_p, node_p->rqt) ;

        if (ret == CY_AS_ERROR_SUCCESS)

        {

            break ;

        }

        /*

        * If an error occurs in sending the request, tell the requester

        * about the error and remove the request from the queue.

        */

        CyAsRequestSetNodeState(node_p, CY_AS_REQUEST_LIST_STATE_RECEIVED) ;

        node_p->callback(dev_p, ctxt_p->number, node_p->rqt, node_p->resp, ret) ;

        CyAsLLRemoveRequestQueueHead(dev_p, ctxt_p) ;

        /*

        * This falls through to the while loop to send the next request since

        * the previous request did not get sent.

        */

    }

}

/*

* This method removes an entry from the request queue of a given context.  The entry

* is removed only if it is not in transit.

*/

CyAsRemoveRequestResult_t

CyAsLLRemoveRequest(CyAsDevice *dev_p, CyAsContext *ctxt_p, CyAsLLRequestResponse *req_p, CyBool force)

{

    uint32_t imask ;

    CyAsLLRequestListNode *node_p ;

    CyAsLLRequestListNode *tmp_p ;

    uint32_t state ;

    imask = CyAsHalDisableInterrupts() ;

    if (ctxt_p->request_queue_p != 0 && ctxt_p->request_queue_p->rqt == req_p)

    {

        node_p = ctxt_p->request_queue_p ;

        if ((CyAsRequestGetNodeState(node_p) == CY_AS_REQUEST_LIST_STATE_WAITING) && (!force))

        {

            CyAsHalEnableInterrupts(imask) ;

            return CyAsRemoveRequestInTransit ;

        }

        ctxt_p->request_queue_p = node_p->next ;

    }

    else

    {

        tmp_p = ctxt_p->request_queue_p ;

        while (tmp_p != 0 && tmp_p->next != 0 && tmp_p->next->rqt != req_p)

            tmp_p = tmp_p->next ;

        if (tmp_p == 0 || tmp_p->next == 0)

        {

            CyAsHalEnableInterrupts(imask) ;

            return CyAsRemoveRequestNotFound ;

        }

        node_p = tmp_p->next ;

        tmp_p->next = node_p->next ;

    }

    if (node_p->callback)

        node_p->callback(dev_p, ctxt_p->number, node_p->rqt, node_p->resp, CY_AS_ERROR_CANCELED) ;

    state = CyAsHalDisableInterrupts() ;

    CyAsHalCBFree(node_p) ;

    CyAsHalEnableInterrupts(state) ;

    CyAsHalEnableInterrupts(imask) ;

    return CyAsRemoveRequestSucessful ;

}

void

CyAsLLRemoveAllRequests(CyAsDevice *dev_p, CyAsContext *ctxt_p)

{

    CyAsLLRequestListNode *node = ctxt_p->request_queue_p ;

    while(node)

    {

        if(CyAsRequestGetNodeState(ctxt_p->request_queue_p) != CY_AS_REQUEST_LIST_STATE_RECEIVED)

            CyAsLLRemoveRequest(dev_p, ctxt_p, node->rqt, CyTrue) ;

        node = node->next ;

    }

}

static CyBool

CyAsLLIsInQueue(CyAsContext *ctxt_p, CyAsLLRequestResponse *req_p)

{

    uint32_t mask ;

    CyAsLLRequestListNode *node_p ;

    mask = CyAsHalDisableInterrupts() ;

    node_p = ctxt_p->request_queue_p ;

    while (node_p)

    {

        if (node_p->rqt == req_p)

        {

            CyAsHalEnableInterrupts(mask) ;

            return CyTrue ;

        }

        node_p = node_p->next ;

    }

    CyAsHalEnableInterrupts(mask) ;

    return CyFalse ;

}

/*

* This is the handler for mailbox data when we are trying to send data to the West Bridge firmware.  The

* firmware may be trying to send us data and we need to queue this data to allow the firmware to move

* forward and be in a state to receive our request.  Here we just queue the data and it is processed

* at a later time by the mailbox interrupt handler.

*/

void

CyAsLLQueueMailboxData(CyAsDevice *dev_p)

{

    CyAsContext *ctxt_p ;

    uint8_t context ;

    uint16_t data[4] ;

    int32_t i ;

    /* Read the data from mailbox 0 to determine what to do with the data */

    for(i = 3 ; i >= 0 ; i--)

        data[i] = CyAsHalReadRegister(dev_p->tag, CyCastInt2UInt16(CY_AS_MEM_P0_MAILBOX0 + i)) ;

    context = CyAsMboxGetContext(data[0]) ;

    if (context >= CY_RQT_CONTEXT_COUNT)

    {

        CyAsHalPrintMessage("Mailbox request/response received with invalid context value (%d)\n", context) ;

        return ;

    }

    ctxt_p = dev_p->context[context] ;

    /*

    * If we have queued too much data, drop future data.

    */

    CyAsHalAssert(ctxt_p->queue_index * sizeof(uint16_t) + sizeof(data) <= sizeof(ctxt_p->data_queue)) ;

    for(i = 0 ; i < 4 ; i++)

        ctxt_p->data_queue[ctxt_p->queue_index++] = data[i] ;

    CyAsHalAssert((ctxt_p->queue_index % 4) == 0) ;

    dev_p->ll_queued_data = CyTrue ;

}

void

CyAsMailBoxProcessData(CyAsDevice *dev_p, uint16_t *data)

{

    CyAsContext *ctxt_p ;

    uint8_t context ;

    uint16_t *len_p ;

    CyAsLLRequestResponse *rec_p ;

    uint8_t st ;

    uint16_t src, dest ;

    context = CyAsMboxGetContext(data[0]) ;

    if (context >= CY_RQT_CONTEXT_COUNT)

    {

        CyAsHalPrintMessage("Mailbox request/response received with invalid context value (%d)\n", context) ;

        return ;

    }

    ctxt_p = dev_p->context[context] ;

    if (CyAsMboxIsRequest(data[0]))

    {

        CyAsHalAssert(ctxt_p->req_p != 0) ;

        rec_p = ctxt_p->req_p ;

        len_p = &ctxt_p->request_length ;

    }

    else

    {

        if (ctxt_p->request_queue_p == 0 || CyAsRequestGetNodeState(ctxt_p->request_queue_p) != CY_AS_REQUEST_LIST_STATE_WAITING)

        {

            CyAsHalPrintMessage("Mailbox response received on context that was not expecting a response\n") ;

            CyAsHalPrintMessage("    Context: %d\n", context) ;

            CyAsHalPrintMessage("    Contents: 0x%04x 0x%04x 0x%04x 0x%04x\n", data[0], data[1], data[2], data[3]) ;

            if (ctxt_p->request_queue_p != 0)

                CyAsHalPrintMessage("    State: 0x%02x\n", ctxt_p->request_queue_p->state) ;

            return ;

        }

        /* Make sure the request has an associated response */

        CyAsHalAssert(ctxt_p->request_queue_p->resp != 0) ;

        rec_p = ctxt_p->request_queue_p->resp ;

        len_p = &ctxt_p->request_queue_p->length ;

    }

    if (rec_p->stored == 0)

    {

        /*

        * This is the first cycle of the response

        */

        CyAsLLRequestResponse_SetCode(rec_p, CyAsMboxGetCode(data[0])) ;

        CyAsLLRequestResponse_SetContext(rec_p, context) ;

        if (CyAsMboxIsLast(data[0]))

        {

            /* This is a single cycle response */

            *len_p = rec_p->length ;

            st = 1 ;

        }

        else

        {

            /* Ensure that enough memory has been reserved for the response. */

            CyAsHalAssert(rec_p->length >= data[1]) ;

            *len_p = (data[1] < rec_p->length) ? data[1] : rec_p->length ;

            st = 2 ;

        }

    }

    else

        st = 1 ;

    /* Trasnfer the data from the mailboxes to the response */

    while (rec_p->stored < *len_p && st < 4)

        rec_p->data[rec_p->stored++] = data[st++] ;

    if (CyAsMboxIsLast(data[0]))

    {

        /* NB: The call-back that is made below can cause the addition of more data

        in this queue, thus causing a recursive overflow of the queue. This is prevented

        by removing the request entry that is currently being passed up from the data

        queue. If this is done, the queue only needs to be as long as two request

        entries from West Bridge.

        */

        if ((ctxt_p->rqt_index > 0) && (ctxt_p->rqt_index <= ctxt_p->queue_index))

        {

            dest = 0 ;

            src  = ctxt_p->rqt_index ;

            while (src < ctxt_p->queue_index)

                ctxt_p->data_queue[dest++] = ctxt_p->data_queue[src++] ;

            ctxt_p->rqt_index = 0 ;

            ctxt_p->queue_index = dest ;

            CyAsHalAssert((ctxt_p->queue_index % 4) == 0) ;

        }

        if (ctxt_p->request_queue_p != 0 && rec_p == ctxt_p->request_queue_p->resp)

        {

            /*

            * If this is the last cycle of the response, call the callback and

            * reset for the next response.

            */

            CyAsLLRequestResponse *resp_p = ctxt_p->request_queue_p->resp ;

            resp_p->length = ctxt_p->request_queue_p->length ;

            CyAsRequestSetNodeState(ctxt_p->request_queue_p, CY_AS_REQUEST_LIST_STATE_RECEIVED) ;

            CyAsDeviceSetInCallback(dev_p) ;

            ctxt_p->request_queue_p->callback(dev_p, context, ctxt_p->request_queue_p->rqt, resp_p, CY_AS_ERROR_SUCCESS) ;

            CyAsDeviceClearInCallback(dev_p) ;

            CyAsLLRemoveRequestQueueHead(dev_p, ctxt_p) ;

            CyAsLLSendNextRequest(dev_p, ctxt_p) ;

        }

        else

        {

            /* Send the request to the appropriate module to handle */

            CyAsLLRequestResponse *request_p = ctxt_p->req_p ;

            ctxt_p->req_p = 0 ;

            if (ctxt_p->request_callback)

            {

                CyAsDeviceSetInCallback(dev_p) ;

                ctxt_p->request_callback(dev_p, context, request_p, 0, CY_AS_ERROR_SUCCESS) ;

                CyAsDeviceClearInCallback(dev_p) ;

            }

            CyAsLLInitRequest(request_p, 0, context, request_p->length) ;

            ctxt_p->req_p = request_p ;

        }

    }

}

/*

* This is the handler for processing queued mailbox data

*/

void

CyAsMailBoxQueuedDataHandler(CyAsDevice *dev_p)

{

    uint16_t i ;

    /*

     * If more data gets queued in between our entering this call and the

     * end of the iteration on all contexts; we should continue processing the

     * queued data.

     */

    while (dev_p->ll_queued_data)

    {

        dev_p->ll_queued_data = CyFalse ;

        for(i = 0 ; i < CY_RQT_CONTEXT_COUNT ; i++)

        {

            uint16_t offset ;

            CyAsContext *ctxt_p = dev_p->context[i] ;

            CyAsHalAssert((ctxt_p->queue_index % 4) == 0) ;

            offset = 0 ;

            while (offset < ctxt_p->queue_index)

            {

                ctxt_p->rqt_index = offset + 4 ;

                CyAsMailBoxProcessData(dev_p, ctxt_p->data_queue + offset) ;

                offset = ctxt_p->rqt_index ;

            }

            ctxt_p->queue_index = 0 ;

        }

    }

}

/*

* This is the handler for the mailbox interrupt.  This function reads data from the mailbox registers

* until a complete request or response is received.  When a complete request is received, the callback

* associated with requests on that context is called.  When a complete response is recevied, the callback

* associated with the request that generated the reponse is called.

*/

void

CyAsMailBoxInterruptHandler(CyAsDevice *dev_p)

{

    CyAsHalAssert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE) ;

    /*

    * Queue the mailbox data to preserve order for later processing.

    */

    CyAsLLQueueMailboxData(dev_p) ;

    /*

    * Process what was queued and anything that may be pending

    */

    CyAsMailBoxQueuedDataHandler(dev_p) ;

}

CyAsReturnStatus_t

CyAsLLStart(CyAsDevice *dev_p)

{

    uint16_t i ;

    if (CyAsDeviceIsLowLevelRunning(dev_p))

        return CY_AS_ERROR_ALREADY_RUNNING ;

    dev_p->ll_sending_rqt = CyFalse ;

    dev_p->ll_abort_curr_rqt = CyFalse ;

    for(i = 0 ; i < CY_RQT_CONTEXT_COUNT ; i++)

    {

        dev_p->context[i] = (CyAsContext *)CyAsHalAlloc(sizeof(CyAsContext)) ;

        if (dev_p->context[i] == 0)

            return CY_AS_ERROR_OUT_OF_MEMORY ;

        dev_p->context[i]->number = (uint8_t)i ;

        dev_p->context[i]->request_callback = 0 ;

        dev_p->context[i]->request_queue_p = 0 ;

        dev_p->context[i]->last_node_p = 0 ;

        dev_p->context[i]->req_p = CyAsLLCreateRequest(dev_p, 0, (uint8_t)i, MaxRequestLength[i]) ;

        dev_p->context[i]->queue_index = 0 ;

        if (!CyAsHalCreateSleepChannel(&dev_p->context[i]->channel))

            return CY_AS_ERROR_CREATE_SLEEP_CHANNEL_FAILED ;

    }

    CyAsDeviceSetLowLevelRunning(dev_p) ;

    return CY_AS_ERROR_SUCCESS ;

}

/*

* Shutdown the low level communications module.  This operation will also cancel any

* queued low level requests.

*/

CyAsReturnStatus_t

CyAsLLStop(CyAsDevice *dev_p)

{

    uint8_t i ;

    CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

    CyAsContext *ctxt_p ;

    uint32_t mask ;

    for(i = 0 ; i < CY_RQT_CONTEXT_COUNT ; i++)

    {

        ctxt_p = dev_p->context[i] ;

        if (!CyAsHalDestroySleepChannel(&ctxt_p->channel))

            return CY_AS_ERROR_DESTROY_SLEEP_CHANNEL_FAILED ;

        /*

        * Now, free any queued requests and assocaited responses

        */

        while (ctxt_p->request_queue_p)

        {

            uint32_t state ;

            CyAsLLRequestListNode *node_p = ctxt_p->request_queue_p ;

            /* Mark this pair as in a cancel operation */

            CyAsRequestSetNodeState(node_p, CY_AS_REQUEST_LIST_STATE_CANCELING) ;

            /* Tell the caller that we are canceling this request */

            /* NB: The callback is responsible for destroying the request and the

            response.  We cannot count on the contents of these two after

            calling the callback.

            */

            node_p->callback(dev_p, i, node_p->rqt, node_p->resp, CY_AS_ERROR_CANCELED) ;

            /* Remove the pair from the queue */

            mask = CyAsHalDisableInterrupts() ;

            ctxt_p->request_queue_p = node_p->next ;

            CyAsHalEnableInterrupts(mask) ;

            /* Free the list node */

            state = CyAsHalDisableInterrupts() ;

            CyAsHalCBFree(node_p) ;

            CyAsHalEnableInterrupts(state) ;

        }

        CyAsLLDestroyRequest(dev_p, dev_p->context[i]->req_p) ;

        CyAsHalFree(dev_p->context[i]) ;

        dev_p->context[i] = 0 ;

    }

    CyAsDeviceSetLowLevelStopped(dev_p) ;

    return ret ;

}

void