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

#include "cyaserr.h"

#include "cyasdma.h"

#include "cyaslowlevel.h"

#include "cyaslep2pep.h"

#include "cyasregs.h"

#include "cyasstorage.h"

extern CyAsMediaType

CyAsStorageGetMediaFromAddress(uint16_t v) ;

extern CyAsBusNumber_t

CyAsStorageGetBusFromAddress(uint16_t v) ;

extern uint32_t

CyAsStorageGetDeviceFromAddress(uint16_t v) ;

static CyAsReturnStatus_t

CyAsUsbAckSetupPacket(

                      CyAsDeviceHandle                  handle,         /* Handle to the West Bridge device */

                      CyAsFunctionCallback              cb,             /* The callback if async call */

                      uint32_t                          client          /* Client supplied data */

                      ) ;

static void

CyAsUsbFuncCallback(

                    CyAsDevice *dev_p,

                    uint8_t context,

                    CyAsLLRequestResponse *rqt,

                    CyAsLLRequestResponse *resp,

                    CyAsReturnStatus_t ret) ;

/*

* Reset the USB EP0 state

*/

static void

CyAsUsbResetEP0State(CyAsDevice *dev_p)

{

    CyAsLogDebugMessage(6, "CyAsUsbResetEP0State called") ;

    CyAsDeviceClearAckDelayed(dev_p) ;

    CyAsDeviceClearSetupPacket(dev_p) ;

    if (CyAsDeviceIsUsbAsyncPending(dev_p, 0))

        CyAsUsbCancelAsync((CyAsDeviceHandle)dev_p, 0) ;

    dev_p->usb_pending_buffer = 0 ;

}

/*

* External function to map logical endpoints to physical endpoints

*/

static CyAsReturnStatus_t

IsUsbActive(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->usb_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

UsbAckCallback(CyAsDeviceHandle h,

               CyAsReturnStatus_t status,

               uint32_t client,

               CyAsFunctCBType  type,

               void* data)

{

    CyAsDevice *dev_p = (CyAsDevice *)h ;

    (void)client ;

    (void)status ;

    (void)data ;

    CyAsHalAssert(type == CY_FUNCT_CB_NODATA) ;

    if (dev_p->usb_pending_buffer)

    {

        CyAsUsbIoCallback cb ;

        cb = dev_p->usb_cb[0] ;

        dev_p->usb_cb[0] = 0 ;

        CyAsDeviceClearUsbAsyncPending(dev_p, 0) ;

        if (cb)

            cb(h, 0, dev_p->usb_pending_size, dev_p->usb_pending_buffer, dev_p->usb_error) ;

        dev_p->usb_pending_buffer = 0 ;

    }

    CyAsDeviceClearSetupPacket(dev_p) ;

}

static void

MyUsbRequestCallbackUsbEvent(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)

{

    uint16_t ev ;

    uint16_t val ;

    CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;

    ev = CyAsLLRequestResponse_GetWord(req_p, 0) ;

    switch(ev)

    {

    case 0:             /* Reserved */

        CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_INVALID_REQUEST, 0) ;

        break ;

    case 1:             /* Reserved */

        CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_INVALID_REQUEST, 0) ;

        break ;

    case 2:             /* USB Suspend */

        dev_p->usb_last_event = CyAsEventUsbSuspend ;

        if (dev_p->usb_event_cb_ms)

            dev_p->usb_event_cb_ms(h, CyAsEventUsbSuspend, 0) ;

        else if (dev_p->usb_event_cb)

            dev_p->usb_event_cb(h, CyAsEventUsbSuspend, 0) ;

        CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

        break;

    case 3:             /* USB Resume */

        dev_p->usb_last_event = CyAsEventUsbResume ;

        if (dev_p->usb_event_cb_ms)

            dev_p->usb_event_cb_ms(h, CyAsEventUsbResume, 0) ;

        else if (dev_p->usb_event_cb)

            dev_p->usb_event_cb(h, CyAsEventUsbResume, 0) ;

        CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

        break ;

    case 4:             /* USB Reset */

        /*

        * If we get a USB reset, the USB host did not understand our response

        * or we timed out for some reason.  Reset our internal state to be ready for

        * another set of enumeration based requests.

        */

        if (CyAsDeviceIsAckDelayed(dev_p))

        {

            CyAsUsbResetEP0State(dev_p) ;

        }

        dev_p->usb_last_event = CyAsEventUsbReset ;

        if (dev_p->usb_event_cb_ms)

            dev_p->usb_event_cb_ms(h, CyAsEventUsbReset, 0) ;

        else if (dev_p->usb_event_cb)

            dev_p->usb_event_cb(h, CyAsEventUsbReset, 0) ;

        CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

        CyAsDeviceClearUsbHighSpeed(dev_p) ;

        CyAsUsbSetDmaSizes(dev_p) ;

        dev_p->usb_max_tx_size = 0x40 ;

        CyAsDmaSetMaxDmaSize(dev_p, 0x06, 0x40) ;

        break ;

    case 5:             /* USB Set Configuration */

        val = CyAsLLRequestResponse_GetWord(req_p, 1) ;                 /* The configuration to set */

        dev_p->usb_last_event = CyAsEventUsbSetConfig ;

        if (dev_p->usb_event_cb_ms)

            dev_p->usb_event_cb_ms(h, CyAsEventUsbSetConfig, &val) ;

        else if (dev_p->usb_event_cb)

            dev_p->usb_event_cb(h, CyAsEventUsbSetConfig, &val) ;

        CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

        break ;

    case 6:             /* USB Speed change */

        val = CyAsLLRequestResponse_GetWord(req_p, 1) ;                 /* Connect speed */

        dev_p->usb_last_event = CyAsEventUsbSpeedChange ;

        if (dev_p->usb_event_cb_ms)

            dev_p->usb_event_cb_ms(h, CyAsEventUsbSpeedChange, &val) ;

        else if (dev_p->usb_event_cb)

            dev_p->usb_event_cb(h, CyAsEventUsbSpeedChange, &val) ;

        CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

        CyAsDeviceSetUsbHighSpeed(dev_p) ;

        CyAsUsbSetDmaSizes(dev_p) ;

        dev_p->usb_max_tx_size = 0x200 ;

        CyAsDmaSetMaxDmaSize(dev_p, 0x06, 0x200) ;

        break ;

    case 7:             /* USB Clear Feature */

        val = CyAsLLRequestResponse_GetWord(req_p, 1) ;                 /* EP Number */

        if (dev_p->usb_event_cb_ms)

            dev_p->usb_event_cb_ms(h, CyAsEventUsbClearFeature, &val) ;

        if (dev_p->usb_event_cb)

            dev_p->usb_event_cb(h, CyAsEventUsbClearFeature, &val) ;

        CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

        break ;

    default:

        CyAsHalPrintMessage("Invalid event type\n") ;

        CyAsLLSendDataResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_RESP_USB_INVALID_EVENT, sizeof(ev), &ev) ;

        break ;

    }

}

static void

MyUsbRequestCallbackUsbData(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)

{

    CyAsEndPointNumber_t ep ;

    uint8_t type ;

    uint16_t len ;

    uint16_t val ;

    CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;

    val = CyAsLLRequestResponse_GetWord(req_p, 0) ;

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

    len = (val & 0x1ff) ;

    CyAsHalAssert(len <= 64) ;

    CyAsLLRequestResponse_Unpack(req_p, 1, len, dev_p->usb_ep_data) ;

    type = (uint8_t)((val >> 14) & 0x03) ;

    if (type == 0)

    {

        if (CyAsDeviceIsAckDelayed(dev_p))

        {

            /*

            * A setup packet has arrived while we are processing a previous setup packet.

            * Reset our state with respect to EP0 to be ready to process the new packet.

            */

            CyAsUsbResetEP0State(dev_p) ;

        }

        if (len != 8)

            CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_INVALID_REQUEST, 0) ;

        else

        {

            CyAsDeviceClearEp0Stalled(dev_p) ;

            CyAsDeviceSetSetupPacket(dev_p) ;

            CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

            if (dev_p->usb_event_cb_ms)

                dev_p->usb_event_cb_ms(h, CyAsEventUsbSetupPacket, dev_p->usb_ep_data) ;

            else

                dev_p->usb_event_cb(h, CyAsEventUsbSetupPacket, dev_p->usb_ep_data) ;

            if ((!CyAsDeviceIsAckDelayed(dev_p)) && (!CyAsDeviceIsEp0Stalled(dev_p)))

            {

                CyAsUsbAckSetupPacket(h, UsbAckCallback, 0) ;

            }

        }

    }

    else if (type == 2)

    {

        if (len != 0)

            CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_INVALID_REQUEST, 0) ;

        else

        {

            if (dev_p->usb_event_cb_ms)

                dev_p->usb_event_cb_ms(h, CyAsEventUsbStatusPacket, 0) ;

            else

                dev_p->usb_event_cb(h, CyAsEventUsbStatusPacket, 0) ;

            CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

        }

    }

    else if (type == 1)

    {

        /*

        * We need to hand the data associated with these endpoints to the DMA

        * module.

        */

        CyAsDmaReceivedData(dev_p, ep, len, dev_p->usb_ep_data) ;

        CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;

    }

}

static void

MyUsbRequestCallbackInquiry(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)

{

    CyAsUsbInquiryData_dep cbdata ;

    CyAsUsbInquiryData cbdata_ms ;

    void *data ;

    uint16_t val ;

    CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;

    uint8_t def_inq_data[64] ;

    uint8_t evpd ;

    uint8_t codepage ;

    CyBool updated ;

    uint16_t length ;

    CyAsBusNumber_t bus ;

    uint32_t        device ;

    CyAsMediaType   media ;

    val    = CyAsLLRequestResponse_GetWord(req_p, 0) ;

    bus    = CyAsStorageGetBusFromAddress(val) ;

    device = CyAsStorageGetDeviceFromAddress(val) ;

    media  = CyAsStorageGetMediaFromAddress(val) ;

    val      = CyAsLLRequestResponse_GetWord(req_p, 1) ;

    evpd     = (uint8_t)((val >> 8) & 0x01) ;

    codepage = (uint8_t)(val & 0xff) ;

    length = CyAsLLRequestResponse_GetWord(req_p, 2) ;

    data   = (void *)def_inq_data ;

    updated = CyFalse ;

    if (dev_p->usb_event_cb_ms)

    {

        cbdata_ms.bus = bus ;

        cbdata_ms.device = device ;

        cbdata_ms.updated = updated ;

        cbdata_ms.evpd = evpd ;

        cbdata_ms.codepage = codepage ;

        cbdata_ms.length = length ;

        cbdata_ms.data = data ;

        CyAsHalAssert(cbdata_ms.length <= sizeof(def_inq_data)) ;

        CyAsLLRequestResponse_Unpack(req_p, 3, cbdata_ms.length, cbdata_ms.data) ;

        dev_p->usb_event_cb_ms(h, CyAsEventUsbInquiryBefore, &cbdata_ms) ;

        updated = cbdata_ms.updated;

        data    = cbdata_ms.data ;

        length  = cbdata_ms.length ;

    }

    else if (dev_p->usb_event_cb)

    {

        cbdata.media = media ;

        cbdata.updated = updated ;

        cbdata.evpd = evpd ;

        cbdata.codepage = codepage ;

        cbdata.length = length ;

        cbdata.data = data ;

        CyAsHalAssert(cbdata.length <= sizeof(def_inq_data)) ;

        CyAsLLRequestResponse_Unpack(req_p, 3, cbdata.length, cbdata.data) ;

        dev_p->usb_event_cb(h, CyAsEventUsbInquiryBefore, &cbdata) ;

        updated = cbdata.updated ;

        data    = cbdata.data ;

        length  = cbdata.length ;

    }

    if (updated && length > 192)

        CyAsHalPrintMessage("An inquiry result from a CyAsEventUsbInquiryBefore event was greater than 192 bytes.") ;

    /* Now send the reply with the data back to the West Bridge device */

    if (updated && length <= 192)

    {

        /*

        * The callback function modified the inquiry data, ship the data back

        * to the West Bridge firmware.

        */

        CyAsLLSendDataResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_RESP_INQUIRY_DATA, length, data) ;

    }

    else

    {

        /*

        * The callback did not modify the data, just acknowledge that we

        * processed the request

        */

        CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 1) ;

    }

    if (dev_p->usb_event_cb_ms)

        dev_p->usb_event_cb_ms(h, CyAsEventUsbInquiryAfter, &cbdata_ms) ;

    else if (dev_p->usb_event_cb)

        dev_p->usb_event_cb(h, CyAsEventUsbInquiryAfter, &cbdata) ;

}

static void

MyUsbRequestCallbackStartStop(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)

{

    CyAsBusNumber_t bus ;

    CyAsMediaType media ;

    uint32_t device ;

    uint16_t val ;

    if (dev_p->usb_event_cb_ms || dev_p->usb_event_cb)

    {

        CyBool loej ;

        CyBool start ;

        CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;

        val = CyAsLLRequestResponse_GetWord(req_p, 0) ;

        bus = CyAsStorageGetBusFromAddress(val) ;

        device = CyAsStorageGetDeviceFromAddress(val) ;

        media = CyAsStorageGetMediaFromAddress(val) ;

        val = CyAsLLRequestResponse_GetWord(req_p, 1) ;

        loej = (val & 0x02) ? CyTrue : CyFalse ;

        start = (val & 0x01) ? CyTrue: CyFalse ;

        if (dev_p->usb_event_cb_ms)

        {

            CyAsUsbStartStopData cbdata_ms ;

            cbdata_ms.bus = bus ;

            cbdata_ms.device = device ;

            cbdata_ms.loej = loej ;

            cbdata_ms.start = start ;

            dev_p->usb_event_cb_ms(h, CyAsEventUsbStartStop, &cbdata_ms) ;

        }

        else if (dev_p->usb_event_cb)

        {

            CyAsUsbStartStopData_dep cbdata ;

            cbdata.media = media ;

            cbdata.loej = loej ;

            cbdata.start = start ;

            dev_p->usb_event_cb(h, CyAsEventUsbStartStop, &cbdata) ;

        }

    }

    CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 1) ;

}

static void

MyUsbRequestCallbackUknownCBW(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)

{

    uint16_t val ;

    CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;

    uint8_t buf[16] ;

    uint8_t response[4] ;

    uint16_t reqlen ;

    void *request ;

    uint8_t status ;

    uint8_t key ;

    uint8_t asc ;

    uint8_t ascq ;

    val = CyAsLLRequestResponse_GetWord(req_p, 0) ;

    status = 1 ;                                            /* Failed by default */

    key = 0x05 ;                                            /* Invalid command */

    asc = 0x20 ;                                            /* Invalid command */

    ascq = 0x00 ;                                   /* Invalid command */

    reqlen = CyAsLLRequestResponse_GetWord(req_p, 1) ;

    request = buf ;

    CyAsHalAssert(reqlen <= sizeof(buf)) ;

    CyAsLLRequestResponse_Unpack(req_p, 2, reqlen, request) ;

    if (dev_p->usb_event_cb_ms)

    {

        CyAsUsbUnknownCommandData cbdata_ms ;

        cbdata_ms.bus = CyAsStorageGetBusFromAddress(val) ;

        cbdata_ms.device = CyAsStorageGetDeviceFromAddress(val) ;

        cbdata_ms.reqlen = reqlen ;

        cbdata_ms.request = request ;

        cbdata_ms.status = status ;

        cbdata_ms.key = key ;

        cbdata_ms.asc = asc ;

        cbdata_ms.ascq = ascq ;

        dev_p->usb_event_cb_ms(h, CyAsEventUsbUnknownStorage, &cbdata_ms) ;

        status = cbdata_ms.status ;

        key = cbdata_ms.key ;

        asc = cbdata_ms.asc ;

        ascq = cbdata_ms.ascq ;

    }

    else if (dev_p->usb_event_cb)

    {

        CyAsUsbUnknownCommandData_dep cbdata ;

        cbdata.media = CyAsStorageGetMediaFromAddress(val) ;

        cbdata.reqlen = reqlen ;

        cbdata.request = request ;

        cbdata.status = status ;

        cbdata.key = key ;

        cbdata.asc = asc ;

        cbdata.ascq = ascq ;

        dev_p->usb_event_cb(h, CyAsEventUsbUnknownStorage, &cbdata) ;

        status = cbdata.status ;

        key = cbdata.key ;

        asc = cbdata.asc ;

        ascq = cbdata.ascq ;

    }

    response[0] = status ;

    response[1] = key ;

    response[2] = asc ;

    response[3] = ascq ;

    CyAsLLSendDataResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_RESP_UNKNOWN_SCSI_COMMAND, sizeof(response), response) ;

}

static void

MyUsbRequestCallbackMSCProgress(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)

{

    uint16_t val1, val2 ;

    CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;

    if ((dev_p->usb_event_cb) || (dev_p->usb_event_cb_ms))

    {

        CyAsMSCProgressData cbdata ;

        val1 = CyAsLLRequestResponse_GetWord(req_p, 0) ;

        val2 = CyAsLLRequestResponse_GetWord(req_p, 1) ;

        cbdata.wr_count = (uint32_t)((val1 << 16) | val2) ;

        val1 = CyAsLLRequestResponse_GetWord(req_p, 2) ;

        val2 = CyAsLLRequestResponse_GetWord(req_p, 3) ;

        cbdata.rd_count = (uint32_t)((val1 << 16) | val2) ;

        if (dev_p->usb_event_cb)

            dev_p->usb_event_cb(h, CyAsEventUsbMSCProgress, &cbdata) ;

        else

            dev_p->usb_event_cb_ms(h, CyAsEventUsbMSCProgress, &cbdata) ;

    }