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

##

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

*/

/*

* Storage Design

*

* The storage module is fairly straight forward once the DMA and LOWLEVEL modules

* have been designed.  The storage module simple takes requests from the user, queues the

* associated DMA requests for action, and then sends the low level requests to the

* West Bridge firmware.

*

*/

#include "cyashal.h"

#include "cyasstorage.h"

#include "cyaserr.h"

#include "cyasdevice.h"

#include "cyaslowlevel.h"

#include "cyasdma.h"

#include "cyasregs.h"

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

CyAsReturnStatus_t

CyAnMapBusFromMediaType(CyAsDevice *dev_p, CyAsMediaType type, CyAsBusNumber_t *bus)

{

    CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

    uint8_t code = (uint8_t)(1 << type) ;

    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 ;

    if (dev_p->media_supported[0] & code)

    {

        if (dev_p->media_supported[1] & code)

        {

            /*

             * This media type could be supported on multiple buses. So, report

             * an address resolution error.

             */

            ret = CY_AS_ERROR_ADDRESS_RESOLUTION_ERROR ;

        }

        else

            *bus = 0 ;

    }

    else

    {

        if (dev_p->media_supported[1] & code)

            *bus = 1 ;

        else

            ret = CY_AS_ERROR_NO_SUCH_MEDIA ;

    }

    return ret ;

}

static uint16_t

CreateAddress(CyAsBusNumber_t bus, uint32_t device, uint8_t unit)

{

    CyAsHalAssert(bus >= 0  && bus < CY_AS_MAX_BUSES) ;

    CyAsHalAssert(device < 16) ;

    return (uint16_t)(((uint8_t)bus << 12) | (device << 8) | unit) ;

}

CyAsMediaType

CyAsStorageGetMediaFromAddress(uint16_t v)

{

    CyAsMediaType media = CyAsMediaMaxMediaValue ;

    switch(v & 0xFF)

    {

        case 0x00:

            break;

        case 0x01:

            media = CyAsMediaNand ;

            break ;

        case 0x02:

            media = CyAsMediaSDFlash ;

            break ;

        case 0x04:

            media = CyAsMediaMMCFlash ;

            break ;

        case 0x08:

            media = CyAsMediaCEATA ;

            break ;

        case 0x10:

            media = CyAsMediaSDIO ;

            break ;

        default:

            CyAsHalAssert(0) ;

            break ;

    }

    return media ;

}

CyAsBusNumber_t

CyAsStorageGetBusFromAddress(uint16_t v)

{

    CyAsBusNumber_t bus = (CyAsBusNumber_t)((v >> 12) & 0x0f) ;

    CyAsHalAssert(bus >= 0 && bus < CY_AS_MAX_BUSES) ;

    return bus ;

}

uint32_t

CyAsStorageGetDeviceFromAddress(uint16_t v)

{

    return (uint32_t)((v >> 8) & 0x0f) ;

}

static uint8_t

GetUnitFromAddress(uint16_t v)

{

    return (uint8_t)(v & 0xff) ;

}

static CyAsReturnStatus_t

CyAsMapBadAddr(uint16_t val)

{

    CyAsReturnStatus_t ret = CY_AS_ERROR_INVALID_RESPONSE ;

    switch(val)

    {

    case 0:

        ret = CY_AS_ERROR_NO_SUCH_BUS ;

        break ;

    case 1:

        ret = CY_AS_ERROR_NO_SUCH_DEVICE ;

        break ;

    case 2:

        ret = CY_AS_ERROR_NO_SUCH_UNIT ;

        break ;

    case 3:

        ret = CY_AS_ERROR_INVALID_BLOCK ;

        break ;

    }

    return ret ;

}

static void

MyStorageRequestCallback(CyAsDevice *dev_p, uint8_t context, CyAsLLRequestResponse *req_p,

                         CyAsLLRequestResponse *resp_p, CyAsReturnStatus_t ret)

{

    uint16_t val ;

    uint16_t addr ;

    CyAsBusNumber_t bus;

    uint32_t device;

    CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;

    CyAsDmaEndPoint *ep_p = NULL ;

    (void)resp_p ;

    (void)context ;

    (void)ret ;

    switch(CyAsLLRequestResponse_GetCode(req_p))

    {

    case CY_RQT_MEDIA_CHANGED:

        CyAsLLSendStatusResponse(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

        /* Media has either been inserted or removed */

        addr = CyAsLLRequestResponse_GetWord(req_p, 0) ;

        bus = CyAsStorageGetBusFromAddress(addr);

        device = CyAsStorageGetDeviceFromAddress(addr);

        /* Clear the entry for this device to force re-query later */

        CyAsHalMemSet(&(dev_p->storage_device_info[bus][device]), 0,

            sizeof(dev_p->storage_device_info[bus][device])) ;

        val = CyAsLLRequestResponse_GetWord(req_p, 1) ;

        if (dev_p->storage_event_cb_ms)

        {

            if (val == 1)

                dev_p->storage_event_cb_ms(h, bus, device, CyAsStorageRemoved, 0) ;

            else

                dev_p->storage_event_cb_ms(h, bus, device, CyAsStorageInserted, 0) ;

        }

        else if (dev_p->storage_event_cb)

        {

            if (val == 1)

                dev_p->storage_event_cb(h, (CyAsMediaType)bus, CyAsStorageRemoved, 0) ; /*nxz*/

            else

                dev_p->storage_event_cb(h, (CyAsMediaType)bus, CyAsStorageInserted, 0) ; /*nxz*/

        }

        break ;

    case CY_RQT_ANTIOCH_CLAIM:

        CyAsLLSendStatusResponse(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

        if (dev_p->storage_event_cb || dev_p->storage_event_cb_ms)

        {

            val = CyAsLLRequestResponse_GetWord(req_p, 0) ;

            if (dev_p->storage_event_cb_ms)

            {

                if (val & 0x0100)

                    dev_p->storage_event_cb_ms(h, 0, 0, CyAsStorageAntioch, 0) ;

                if (val & 0x0200)

                    dev_p->storage_event_cb_ms(h, 1, 0, CyAsStorageAntioch, 0) ;

            }

            else

            {

                if (val & 0x01)

                    dev_p->storage_event_cb(h, CyAsMediaNand, CyAsStorageAntioch, 0) ;

                if (val & 0x02)

                    dev_p->storage_event_cb(h, CyAsMediaSDFlash, CyAsStorageAntioch, 0) ;

                if (val & 0x04)

                    dev_p->storage_event_cb(h, CyAsMediaMMCFlash, CyAsStorageAntioch, 0) ;

                if (val & 0x08)

                    dev_p->storage_event_cb(h, CyAsMediaCEATA, CyAsStorageAntioch, 0) ;

            }

        }

        break ;

    case CY_RQT_ANTIOCH_RELEASE:

        CyAsLLSendStatusResponse(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

        val = CyAsLLRequestResponse_GetWord(req_p, 0) ;

        if (dev_p->storage_event_cb_ms)

        {

            if (val & 0x0100)

                dev_p->storage_event_cb_ms(h, 0, 0, CyAsStorageProcessor, 0) ;

            if (val & 0x0200)

                dev_p->storage_event_cb_ms(h, 1, 0, CyAsStorageProcessor, 0) ;

        }

        else if (dev_p->storage_event_cb)

        {

            if (val & 0x01)

                dev_p->storage_event_cb(h, CyAsMediaNand, CyAsStorageProcessor, 0) ;

            if (val & 0x02)

                dev_p->storage_event_cb(h, CyAsMediaSDFlash, CyAsStorageProcessor, 0) ;

            if (val & 0x04)

                dev_p->storage_event_cb(h, CyAsMediaMMCFlash, CyAsStorageProcessor, 0) ;

            if (val & 0x08)

                dev_p->storage_event_cb(h, CyAsMediaCEATA, CyAsStorageProcessor, 0) ;

        }

        break ;

    case CY_RQT_SDIO_INTR:

        CyAsLLSendStatusResponse(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

        val = CyAsLLRequestResponse_GetWord(req_p, 0) ;

        if (dev_p->storage_event_cb_ms)

        {

            if (val & 0x0100)

                dev_p->storage_event_cb_ms(h, 1, 0, CyAsSdioInterrupt, 0) ;

            else

                dev_p->storage_event_cb_ms(h, 0, 0, CyAsSdioInterrupt, 0) ;

        }

        else if (dev_p->storage_event_cb)

        {

            dev_p->storage_event_cb(h, CyAsMediaSDIO, CyAsSdioInterrupt, 0) ;

        }

        break;

    case CY_RQT_P2S_DMA_START:

        /* Do the DMA setup for the waiting operation. This event is used only in

         * the MTP mode firmware. */

        CyAsLLSendStatusResponse(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

        if (dev_p->storage_oper == CyAsOpRead)

        {

            ep_p = CY_AS_NUM_EP(dev_p, CY_AS_P2S_READ_ENDPOINT) ;

            CyAsDmaEndPointSetStopped(ep_p) ;

            CyAsDmaKickStart(dev_p, CY_AS_P2S_READ_ENDPOINT) ;

        }

        else

        {

            ep_p = CY_AS_NUM_EP(dev_p, CY_AS_P2S_WRITE_ENDPOINT) ;

            CyAsDmaEndPointSetStopped(ep_p) ;

            CyAsDmaKickStart(dev_p, CY_AS_P2S_WRITE_ENDPOINT) ;

        }

        break ;

    default:

        CyAsHalPrintMessage("Invalid request received on storage context\n") ;

        val = req_p->box0 ;

        CyAsLLSendDataResponse(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, CY_RESP_INVALID_REQUEST, sizeof(val), &val) ;

        break ;

    }

}

static CyAsReturnStatus_t

IsStorageActive(CyAsDevice *dev_p)

{

    if (!CyAsDeviceIsConfigured(dev_p))

        return CY_AS_ERROR_NOT_CONFIGURED ;

    if (!CyAsDeviceIsFirmwareLoaded(dev_p))

        return CY_AS_ERROR_NO_FIRMWARE ;

    if (dev_p->storage_count == 0)

        return CY_AS_ERROR_NOT_RUNNING ;

    if (CyAsDeviceIsInSuspendMode(dev_p))

        return CY_AS_ERROR_IN_SUSPEND ;

    return CY_AS_ERROR_SUCCESS ;

}

static void

CyAsStorageFuncCallback(CyAsDevice *dev_p,

                        uint8_t context,

                        CyAsLLRequestResponse *rqt,

                        CyAsLLRequestResponse *resp,

                        CyAsReturnStatus_t ret) ;

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 ;

        goto destroy ;

    }

    ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;

destroy :

    CyAsLLDestroyRequest(dev_p, req_p) ;

    CyAsLLDestroyResponse(dev_p, reply_p) ;

    return ret ;

}

static CyAsReturnStatus_t

MyHandleResponseStorageStart(CyAsDevice* dev_p,

                         CyAsLLRequestResponse *req_p,

                         CyAsLLRequestResponse *reply_p,

                         CyAsReturnStatus_t ret)

{

    if (ret != CY_AS_ERROR_SUCCESS)

        goto destroy ;

    if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)

    {

        ret = CY_AS_ERROR_INVALID_RESPONSE ;

        goto destroy ;

    }

    ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;

    if (dev_p->storage_count > 0 && ret == CY_AS_ERROR_ALREADY_RUNNING)

        ret = CY_AS_ERROR_SUCCESS ;

    ret = CyAsDmaEnableEndPoint(dev_p, CY_AS_P2S_WRITE_ENDPOINT, CyTrue, CyAsDirectionIn) ;

    if (ret != CY_AS_ERROR_SUCCESS)

        goto destroy ;

    ret = CyAsDmaSetMaxDmaSize(dev_p, CY_AS_P2S_WRITE_ENDPOINT, CY_AS_STORAGE_EP_SIZE) ;

    if (ret != CY_AS_ERROR_SUCCESS)

        goto destroy ;

    ret = CyAsDmaEnableEndPoint(dev_p, CY_AS_P2S_READ_ENDPOINT, CyTrue, CyAsDirectionOut) ;

    if (ret != CY_AS_ERROR_SUCCESS)

        goto destroy ;

    ret = CyAsDmaSetMaxDmaSize(dev_p, CY_AS_P2S_READ_ENDPOINT, CY_AS_STORAGE_EP_SIZE) ;

    if (ret != CY_AS_ERROR_SUCCESS)

        goto destroy ;

    CyAsLLRegisterRequestCallback(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, MyStorageRequestCallback) ;

    /* Create the request/response used for storage reads and writes. */

    dev_p->storage_rw_req_p  = CyAsLLCreateRequest(dev_p, 0, CY_RQT_STORAGE_RQT_CONTEXT, 5) ;

    if (dev_p->storage_rw_req_p == 0)

    {

        ret = CY_AS_ERROR_OUT_OF_MEMORY;

        goto destroy;

    }

    dev_p->storage_rw_resp_p = CyAsLLCreateResponse(dev_p, 5) ;

    if (dev_p->storage_rw_resp_p == 0)

    {

        CyAsLLDestroyRequest(dev_p, dev_p->storage_rw_req_p) ;

        ret = CY_AS_ERROR_OUT_OF_MEMORY ;

    }

destroy :

    CyAsLLDestroyRequest(dev_p, req_p) ;

    CyAsLLDestroyResponse(dev_p, reply_p) ;

    /* Increment the storage count only if the above functionality succeeds.*/

    if (ret == CY_AS_ERROR_SUCCESS)

    {

        if (dev_p->storage_count == 0)

        {

            CyAsHalMemSet(dev_p->storage_device_info, 0, sizeof(dev_p->storage_device_info)) ;

            dev_p->is_storage_only_mode = CyFalse ;

        }

        dev_p->storage_count++ ;

    }

    CyAsDeviceClearSSSPending(dev_p) ;

    return ret ;

}

CyAsReturnStatus_t

CyAsStorageStart(CyAsDeviceHandle handle,

                   CyAsFunctionCallback cb,

                   uint32_t client)

{

    CyAsLLRequestResponse *req_p, *reply_p ;

    CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;

    CyAsDevice *dev_p = (CyAsDevice *)handle ;

    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 ;

    if (CyAsDeviceIsInSuspendMode(dev_p))

        return CY_AS_ERROR_IN_SUSPEND ;

    if(CyAsDeviceIsSSSPending(dev_p))

        return CY_AS_ERROR_STARTSTOP_PENDING ;

    CyAsDeviceSetSSSPending(dev_p) ;

    if (dev_p->storage_count == 0)

    {

        /* Create the request to send to the West Bridge device */

        req_p = CyAsLLCreateRequest(dev_p, CY_RQT_START_STORAGE, CY_RQT_STORAGE_RQT_CONTEXT, 1) ;

        if (req_p == 0)

        {

            CyAsDeviceClearSSSPending(dev_p) ;

            return CY_AS_ERROR_OUT_OF_MEMORY ;

        }

        /* Reserve space for the reply, the reply data will not exceed one word */

        reply_p = CyAsLLCreateResponse(dev_p, 1) ;

        if (reply_p == 0)

        {

            CyAsDeviceClearSSSPending(dev_p) ;

            CyAsLLDestroyRequest(dev_p, req_p) ;

            return CY_AS_ERROR_OUT_OF_MEMORY ;

        }

        if(cb == 0)

        {

            ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;

            if (ret != CY_AS_ERROR_SUCCESS)

                goto destroy ;

            return MyHandleResponseStorageStart(dev_p, req_p, reply_p, ret) ;

        }

        else

        {

            ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_STOR_START,

                0, dev_p->func_cbs_stor, CY_AS_REQUEST_RESPONSE_EX,

                req_p, reply_p, CyAsStorageFuncCallback) ;

            if (ret != CY_AS_ERROR_SUCCESS)

                goto destroy ;

            /* The request and response are freed as part of the FuncCallback */

            return ret ;

        }

destroy:

        CyAsLLDestroyRequest(dev_p, req_p) ;

        CyAsLLDestroyResponse(dev_p, reply_p) ;

    }

    else

    {

        dev_p->storage_count++ ;

        if (cb)

            cb(handle, ret, client, CY_FUNCT_CB_STOR_START, 0) ;

    }

    CyAsDeviceClearSSSPending(dev_p) ;

    return ret ;

}

static CyAsReturnStatus_t

MyHandleResponseStorageStop(CyAsDevice* dev_p,

                         CyAsLLRequestResponse *req_p,

                         CyAsLLRequestResponse *reply_p,

                         CyAsReturnStatus_t ret)

{

    if (ret != CY_AS_ERROR_SUCCESS)

        goto destroy ;

    if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)

    {

        ret = CY_AS_ERROR_INVALID_RESPONSE ;

        goto destroy ;

    }

destroy :

    CyAsLLDestroyRequest(dev_p, req_p) ;

    CyAsLLDestroyResponse(dev_p, reply_p) ;

    if (ret == CY_AS_ERROR_SUCCESS)