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

#include "cyasdma.h"

#include "cyasintr.h"

#include "cyaserr.h"

#include "cyasregs.h"

#include "cyaslowlevel.h"

#include "cyasprotocol.h"

/*

* The device list, the only global in the API

*/

static CyAsDevice *gDeviceList = 0 ;

/*

 * The current debug level

 */

#ifdef CY_AS_LOG_SUPPORT

static uint8_t DebugLevel = 0 ; //commented out as it's not

/*

 * This function sets the debug level for the API

 *

 */

void

CyAsMiscSetLogLevel(uint8_t level)

{

    DebugLevel = level ;

}

//#ifdef CY_AS_LOG_SUPPORT

/*

 * This function is a low level logger for the API.

 */

void

CyAsLogDebugMessage(int level, const char *str)

{

    if (level <= DebugLevel)

        CyAsHalPrintMessage("Log %d: %s\n", level, str) ;

}

#endif

#define CyAsCheckDeviceReady(dev_p)                                     \

{                                                                       \

    if (!(dev_p) ||((dev_p)->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))     \

        return CY_AS_ERROR_INVALID_HANDLE ;                             \

                                                                        \

    if (!CyAsDeviceIsConfigured(dev_p))                                 \

        return CY_AS_ERROR_NOT_CONFIGURED ;                             \

                                                                        \

    if (!CyAsDeviceIsFirmwareLoaded(dev_p))                             \

        return CY_AS_ERROR_NO_FIRMWARE ;                                \

}

/* Find an West Bridge device based on a TAG */

CyAsDevice *

CyAsDeviceFindFromTag(CyAsHalDeviceTag tag)

{

    CyAsDevice *dev_p ;

    for(dev_p = gDeviceList; dev_p != 0; dev_p = dev_p->next_p)

    {

        if (dev_p->tag == tag)

            return dev_p ;

    }

    return 0 ;

}

/* Map a pre-V1.2 media type to the V1.2+ bus number */

static void

CyAsBusFromMediaType(CyAsMediaType type,

                        CyAsBusNumber_t* bus)

{

    if (type == CyAsMediaNand)

    {

        *bus = 0 ;

    }

    else

    {

        *bus = 1 ;

    }

}

static CyAsReturnStatus_t

MyHandleResponseNoData(CyAsDevice* dev_p,

                         CyAsLLRequestResponse *req_p,

                         CyAsLLRequestResponse *reply_p)

{

    CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

    if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)

        ret = CY_AS_ERROR_INVALID_RESPONSE ;

    else

        ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;

    CyAsLLDestroyRequest(dev_p, req_p) ;

    CyAsLLDestroyResponse(dev_p, reply_p) ;

    return ret ;

}

/*

* Create a new West Bridge device

*/

CyAsReturnStatus_t

CyAsMiscCreateDevice(CyAsDeviceHandle *handle_p, CyAsHalDeviceTag tag)

{

    CyAsDevice *dev_p ;

    CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

    CyAsLogDebugMessage(6, "CyAsMiscCreateDevice called") ;

    dev_p = (CyAsDevice *)CyAsHalAlloc(sizeof(CyAsDevice)) ;

    if (dev_p == 0)

        return CY_AS_ERROR_OUT_OF_MEMORY ;

    CyAsHalMemSet(dev_p, 0, sizeof(CyAsDevice)) ;

    /*

     * Dynamically allocating this buffer to ensure that it is

     * word aligned.

     */

    dev_p->usb_ep_data = (uint8_t *)CyAsHalAlloc(64 * sizeof(uint8_t)) ;

    if (dev_p->usb_ep_data == 0)

    {

        CyAsHalFree(dev_p) ;

        return CY_AS_ERROR_OUT_OF_MEMORY ;

    }

    dev_p->sig = CY_AS_DEVICE_HANDLE_SIGNATURE ;

    dev_p->tag = tag ;

    dev_p->usb_max_tx_size = 0x40 ;

    dev_p->storage_write_endpoint = CY_AS_P2S_WRITE_ENDPOINT ;

    dev_p->storage_read_endpoint = CY_AS_P2S_READ_ENDPOINT ;

    dev_p->func_cbs_misc = CyAsCreateCBQueue(CYAS_FUNC_CB) ;

    if(dev_p->func_cbs_misc == 0)

        goto destroy ;

    dev_p->func_cbs_res = CyAsCreateCBQueue(CYAS_FUNC_CB) ;

    if(dev_p->func_cbs_res == 0)

        goto destroy ;

    dev_p->func_cbs_stor = CyAsCreateCBQueue(CYAS_FUNC_CB) ;

    if(dev_p->func_cbs_stor == 0)

        goto destroy ;

    dev_p->func_cbs_usb = CyAsCreateCBQueue(CYAS_FUNC_CB) ;

    if(dev_p->func_cbs_usb == 0)

        goto destroy ;

    dev_p->func_cbs_mtp = CyAsCreateCBQueue(CYAS_FUNC_CB) ;

    if(dev_p->func_cbs_mtp == 0)

            goto destroy ;

    /*

     * Allocate memory for the DMA module here. It is then marked idle, and

     * will be activated when CyAsMiscConfigureDevice is called.

     */

    ret = CyAsDmaStart(dev_p) ;

    if (ret != CY_AS_ERROR_SUCCESS)

        goto destroy ;

    CyAsDeviceSetDmaStopped(dev_p) ;

    /*

     * Allocate memory for the low level module here. This module is also

     * activated only when CyAsMiscConfigureDevice is called.

     */

    ret = CyAsLLStart(dev_p) ;

    if (ret != CY_AS_ERROR_SUCCESS)

        goto destroy ;

    CyAsDeviceSetLowLevelStopped(dev_p) ;

    dev_p->next_p = gDeviceList ;

    gDeviceList = dev_p ;

    *handle_p = dev_p ;

    CyAsHalInitDevRegisters(tag, CyFalse) ;

    return CY_AS_ERROR_SUCCESS ;

destroy:

    /* Free any queues that were successfully allocated. */

    if (dev_p->func_cbs_misc) CyAsDestroyCBQueue(dev_p->func_cbs_misc) ;

    if (dev_p->func_cbs_res)  CyAsDestroyCBQueue(dev_p->func_cbs_res) ;

    if (dev_p->func_cbs_stor) CyAsDestroyCBQueue(dev_p->func_cbs_stor) ;

    if (dev_p->func_cbs_usb)  CyAsDestroyCBQueue(dev_p->func_cbs_usb) ;

    if (dev_p->func_cbs_mtp)  CyAsDestroyCBQueue(dev_p->func_cbs_mtp) ;

    CyAsHalFree(dev_p->usb_ep_data) ;

    CyAsHalFree(dev_p) ;

    if (ret != CY_AS_ERROR_SUCCESS)

        return ret ;

    else

        return CY_AS_ERROR_OUT_OF_MEMORY ;

}

/*

* Destroy an existing West Bridge device

*/

CyAsReturnStatus_t

CyAsMiscDestroyDevice(CyAsDeviceHandle handle)

{

    CyAsReturnStatus_t ret ;

    CyAsDevice *dev_p ;

    CyAsLogDebugMessage(6, "CyAsMiscDestroyDevice called") ;

    dev_p = (CyAsDevice *)handle ;

    if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))

        return CY_AS_ERROR_INVALID_HANDLE ;

    /*

    * If the USB stack is still running, it must be stopped first

    */

    if (dev_p->usb_count > 0)

        return CY_AS_ERROR_STILL_RUNNING ;

    /*

    * If the STORAGE stack is still running, it must be stopped first

    */

    if (dev_p->storage_count > 0)

        return CY_AS_ERROR_STILL_RUNNING ;

    if(CyAsDeviceIsIntrRunning(dev_p))

        ret = CyAsIntrStop(dev_p) ;

    ret = CyAsLLStop(dev_p) ;

    if (ret != CY_AS_ERROR_SUCCESS)

    {

        CyAsIntrStart(dev_p, dev_p->use_int_drq) ;

        return ret ;

    }

    ret = CyAsDmaStop(dev_p) ;

    if (ret != CY_AS_ERROR_SUCCESS)

    {

        CyAsIntrStart(dev_p, dev_p->use_int_drq) ;

        return ret ;

    }

    /* Reset the West Bridge device. */

    CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_RST_CTRL_REG, CY_AS_MEM_RST_CTRL_REG_HARD) ;

    /*

    * Remove the device from the device list

    */

    if (gDeviceList == dev_p)

    {

        gDeviceList = dev_p->next_p ;

    }

    else

    {

        CyAsDevice *tmp_p = gDeviceList ;

        while (tmp_p && tmp_p->next_p != dev_p)

            tmp_p = tmp_p->next_p ;

        CyAsHalAssert(tmp_p != 0) ;

        tmp_p->next_p = dev_p->next_p ;

    }

    /*

    * Reset the signature so this will not be detected

    * as a valid handle

    */

    dev_p->sig = 0 ;

    CyAsDestroyCBQueue(dev_p->func_cbs_misc) ;

    CyAsDestroyCBQueue(dev_p->func_cbs_res) ;

    CyAsDestroyCBQueue(dev_p->func_cbs_stor) ;

    CyAsDestroyCBQueue(dev_p->func_cbs_usb) ;

    CyAsDestroyCBQueue(dev_p->func_cbs_mtp) ;

    /*

    * Free the memory associated with the device

    */

    CyAsHalFree(dev_p->usb_ep_data) ;

    CyAsHalFree(dev_p) ;

    return CY_AS_ERROR_SUCCESS ;

}

/*

* Determine the endian mode for the processor we are running on, then

* set the endian mode register

*/

static void

CyAsSetupEndianMode(CyAsDevice *dev_p)

{

    /*

    * BWG: In general, we always set West Bridge into the little endian mode.  This

    *      causes the data on bit 0 internally to come out on data line 0 externally

    *      and it is generally what we want regardless of the endian mode of the

    *      processor.  This capability in West Bridge should be labeled as a "SWAP" capability

    *      and can be used to swap the bytes of data in and out of West Bridge.  This is

    *      useful if there is DMA hardware that requires this for some reason I cannot

    *      imagine at this time.  Basically if the wires are connected correctly, we should

    *      never need to change the endian-ness of West Bridge.

    */

    CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_P0_ENDIAN, CY_AS_LITTLE_ENDIAN) ;

}

/*

* Query the West Bridge device and determine if we are an standby mode

*/

CyAsReturnStatus_t

CyAsMiscInStandby(CyAsDeviceHandle handle, CyBool *standby)

{

    CyAsDevice *dev_p ;

    CyAsLogDebugMessage(6, "CyAsMiscInStandby called") ;

    dev_p = (CyAsDevice *)handle ;

    if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))

        return CY_AS_ERROR_INVALID_HANDLE ;

    if (CyAsDeviceIsPinStandby(dev_p) || CyAsDeviceIsRegisterStandby(dev_p))

    {

        *standby = CyTrue ;

    }

    else

        *standby = CyFalse ;

    return CY_AS_ERROR_SUCCESS ;

}

static void

CyAsMiscFuncCallback(CyAsDevice *dev_p,

                        uint8_t context,

                        CyAsLLRequestResponse *rqt,

                        CyAsLLRequestResponse *resp,

                        CyAsReturnStatus_t ret) ;

static void

MyMiscCallback(CyAsDevice *dev_p, uint8_t context, CyAsLLRequestResponse *req_p, CyAsLLRequestResponse *resp_p,

               CyAsReturnStatus_t ret)

{

    (void)resp_p ;

    (void)context ;

    (void)ret ;

    switch (CyAsLLRequestResponse_GetCode(req_p))

    {

        case CY_RQT_INITIALIZATION_COMPLETE:

            {

                uint16_t v ;

                CyAsLLSendStatusResponse(dev_p, CY_RQT_GENERAL_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

                CyAsDeviceSetFirmwareLoaded(dev_p) ;

                if (CyAsDeviceIsWaking(dev_p))

                {

                    /*

                     * This is a callback from a CyAsMiscLeaveStandby() request.  In this case we call the

                     * standby callback and clear the waking state.

                     */

                    if (dev_p->misc_event_cb)

                        dev_p->misc_event_cb((CyAsDeviceHandle)dev_p, CyAsEventMiscAwake, 0) ;

                    CyAsDeviceClearWaking(dev_p) ;

                }

                else

                {

                    v = CyAsLLRequestResponse_GetWord(req_p, 3) ;

                    /*

                     * Store the media supported on each of the device buses.

                     */

                    dev_p->media_supported[0] = (uint8_t)(v & 0xFF) ;

                    dev_p->media_supported[1] = (uint8_t)((v >> 8) & 0xFF) ;

                    v = CyAsLLRequestResponse_GetWord(req_p, 4) ;

                    dev_p->is_mtp_firmware    = (CyBool)((v >> 8) & 0xFF) ;

                    if (dev_p->misc_event_cb)

                        dev_p->misc_event_cb((CyAsDeviceHandle)dev_p, CyAsEventMiscInitialized, 0) ;

                }

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

                if (v & CY_AS_MEM_P0_VM_SET_CFGMODE)

                    CyAsHalPrintMessage("Initialization Message Recieved, but config bit still set\n") ;

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

                if ((v & CY_AS_MEM_RST_RSTCMPT) ==0)

                    CyAsHalPrintMessage("Initialization Message Recieved, but reset complete bit still not set\n") ;

            }

            break ;

        case CY_RQT_OUT_OF_SUSPEND:

            CyAsLLSendStatusResponse(dev_p, CY_RQT_GENERAL_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

            CyAsDeviceClearSuspendMode(dev_p) ;

            /*

             * If the wakeup was caused by an async CyAsMiscLeaveSuspend call, we have to

             * call the corresponding callback.

             */

            if (dev_p->func_cbs_misc->count > 0)

            {

                CyAsFuncCBNode *node = (CyAsFuncCBNode*)dev_p->func_cbs_misc->head_p ;

                CyAsHalAssert(node) ;

                if (CyAsFunctCBTypeGetType(node->dataType) == CY_FUNCT_CB_MISC_LEAVESUSPEND)

                {

                    CyAsHalAssert(node->cb_p != 0) ;

                    node->cb_p((CyAsDeviceHandle)dev_p, CY_AS_ERROR_SUCCESS, node->client_data,

                            CY_FUNCT_CB_MISC_LEAVESUSPEND, 0) ;

                    CyAsRemoveCBNode(dev_p->func_cbs_misc) ;

                }

            }

            if (dev_p->misc_event_cb)

                dev_p->misc_event_cb((CyAsDeviceHandle)dev_p, CyAsEventMiscWakeup, 0) ;

            break ;

        case CY_RQT_DEBUG_MESSAGE:

            if ((req_p->data[0] == 0) && (req_p->data[1] == 0) && (req_p->data[2] == 0))

            {

                if (dev_p->misc_event_cb)

                    dev_p->misc_event_cb((CyAsDeviceHandle)dev_p, CyAsEventMiscHeartBeat, 0) ;

            }

            else

            {

                CyAsHalPrintMessage("**** Debug Message: %02x %02x %02x %02x %02x %02x\n",

                        req_p->data[0] & 0xff, (req_p->data[0] >> 8) & 0xff,

                        req_p->data[1] & 0xff, (req_p->data[1] >> 8) & 0xff,

                        req_p->data[2] & 0xff, (req_p->data[2] >> 8) & 0xff) ;

            }

            break ;

        case CY_RQT_WB_DEVICE_MISMATCH:

            {

                if (dev_p->misc_event_cb)

                    dev_p->misc_event_cb((CyAsDeviceHandle)dev_p, CyAsEventMiscDeviceMismatch, 0) ;

            }

            break ;

        case CY_RQT_BOOTLOAD_NO_FIRMWARE:

            {

                /* TODO Handle case when firmware is not found during bootloading. */

                CyAsHalPrintMessage("No firmware image found during bootload. Device not started\n") ;

            }

            break ;

        default:

            CyAsHalAssert (0) ;

    }

}

static CyBool

IsValidSiliconId(uint16_t v)

{

    CyBool idok = CyFalse ;

    /*

    * Remove the revision number from the ID value

    */

    v = v & CY_AS_MEM_CM_WB_CFG_ID_HDID_MASK ;

    /*

    * If this is West Bridge, then we are OK.

    */

    if (v == CY_AS_MEM_CM_WB_CFG_ID_HDID_ANTIOCH_VALUE ||

        v == CY_AS_MEM_CM_WB_CFG_ID_HDID_ASTORIA_FPGA_VALUE ||

        v == CY_AS_MEM_CM_WB_CFG_ID_HDID_ASTORIA_VALUE)

        idok = CyTrue ;

    return idok ;

}

/*

* Configure the West Bridge device hardware

*/

CyAsReturnStatus_t

CyAsMiscConfigureDevice(CyAsDeviceHandle handle, CyAsDeviceConfig *config_p)

{

    CyAsReturnStatus_t ret ;

    CyBool standby ;

    CyAsDevice *dev_p ;

    uint16_t v ;

    uint16_t fw_present;

    CyAsLogDebugMessage(6, "CyAsMiscConfigureDevice called") ;

    dev_p = (CyAsDevice *)handle ;

    if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))

        return CY_AS_ERROR_INVALID_HANDLE ;

    /* Setup big endian vs little endian */

    CyAsSetupEndianMode(dev_p) ;

    /* Now, confirm that we can talk to the West Bridge device */

    dev_p->silicon_id = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_CM_WB_CFG_ID) ;

    fw_present = CyAsHalReadRegister(dev_p->tag,CY_AS_MEM_RST_CTRL_REG ) ;

    if (!(fw_present & CY_AS_MEM_RST_RSTCMPT))

    {

        if (!IsValidSiliconId(dev_p->silicon_id))

            return CY_AS_ERROR_NO_ANTIOCH ;

    }

    /* Check for standby mode */

    ret = CyAsMiscInStandby(handle, &standby) ;

    if (ret != CY_AS_ERROR_SUCCESS)

        return ret ;

    if (ret)