#include <kern_priv.h>

#include <beagle/beagle_gpio.h>

#include <beagle/variant.h>

#include <assp/omap3530_assp/omap3530_assp_priv.h>

#include <assp/omap3530_assp/omap3530_irqmap.h> // GPIO interrupts

#include <assp/omap3530_assp/omap3530_gpio.h>

#include <assp.h> // Required for definition of TIsr

#include <cyastoria.h>

#include <cyasmtp.h>

#include <cyasusbinit.h>

#include <cyasusbdescs.h>

TmtpAstDev g_AstDevice;

TmtpAstDev * g_pAstDevice = &g_AstDevice ;

static uint16_t replybuf[512] ;

static uint8_t *

GetReplyArea(void)

{

    return (uint8_t *) replybuf ;

}

/* Globals */

/*static uint8_t pktbuffer3[512] ;*/

#ifdef CY_AS_USB_TB_FOUR

static uint8_t pktbuffer7[512] ;

#endif

#ifdef CY_AS_USB_TB_SIX

static uint8_t pktbuffer11[512] ;

#endif

/*static uint8_t turbopktbuffer[512] ;*/

static volatile CyBool gSetConfig = CyFalse ;

static volatile CyBool gAsyncStallDone = CyFalse ;

static volatile CyBool gStorageReleaseBus0 = CyFalse ;

static volatile CyBool gStorageReleaseBus1 = CyFalse ;

static volatile CyAsHalDeviceTag g_tag ;

static uint8_t MyConfiguration = 0 ;

static CyCh9ConfigurationDesc *desc_p = 0 ;

static CyCh9ConfigurationDesc *other_p = 0 ;

static volatile uint8_t gAsyncStallStale = 0;

/* Forward declarations */

static int SetupUSBPPort(CyAsDeviceHandle h, uint8_t media, CyBool isTurbo) ;

static void MyUsbEventCallbackMS(CyAsDeviceHandle h, CyAsUsbEvent ev, void *evdata) ;

static void PrintData(const char *name, uint8_t *data, uint16_t size) ;

static void

StallCallback(CyAsDeviceHandle h, CyAsReturnStatus_t status, uint32_t tag, CyAsFunctCBType cbtype, void *cbdata)

{

    (void)h ;

    (void)cbtype ;

    (void)cbdata ;

    if (tag == 1)

        CyAsHalPrintMessage("*** Nak callback - status = %d\n", status) ;

    else

        CyAsHalPrintMessage("*** Stall callback - status = %d\n", status) ;

}

static void

StallCallbackEX(CyAsDeviceHandle h,

                CyAsReturnStatus_t status,

                uint32_t tag,

                CyAsFunctCBType type,

                void*   data)

{

    (void)h ;

    (void)type ;

    (void)data ;

    (void)status ;

    if(tag == 18)

    {

        CyAsReturnStatus_t ret = CyAsUsbClearStall(h, 3, StallCallbackEX, 21);

        CyAsHalAssert(ret == CY_AS_ERROR_SUCCESS) ;

    }

    else

        gAsyncStallDone = CyTrue ;

}

static void

StallCallbackAsync(CyAsDeviceHandle h, CyAsReturnStatus_t status, uint32_t tag, CyAsFunctCBType cbtype, void *cbdata)

{

    (void)cbtype ;

    (void)cbdata ;

    (void)tag ;

    (void)status ;

    if(gAsyncStallStale == 0)

    {

        gAsyncStallStale++;

        CyAsHalAssert(ret == CY_AS_ERROR_SUCCESS) ;

    }

    else

    {

        gAsyncStallDone = CyTrue ;

    }

}

static void

MyStorageEventCBMS(CyAsDeviceHandle h, CyAsBusNumber_t bus, uint32_t device, CyAsStorageEvent evtype, void *evdata)

{

    (void)h ;

    (void)evdata ;

    switch (evtype)

    {

    case CyAsStorageAntioch:

        CyAsHalPrintMessage("CyAsStorageAntioch Event: bus=%d, device=%d\n", bus, device) ;

        switch (bus)

        {

        case 0:

            gStorageReleaseBus0 = CyTrue ;

            break;

        case 1:

            gStorageReleaseBus1 = CyTrue ;

            break;

        default:

            break;

        }

        break;

    case CyAsStorageProcessor:

        CyAsHalPrintMessage("CyAsStorageProcessor Event: bus=%d, device %d\n", bus, device) ;

        break;

    case CyAsStorageRemoved:

        CyAsHalPrintMessage("Bus %d, device %d has been removed\n", bus, device) ;

        break;

    case CyAsStorageInserted:

        CyAsHalPrintMessage("Bus %d, device %d has been inserted\n", bus, device) ;

        break;

    default:

        break;

    }

}

/*

* This function exercises the USB module

*/

int CyAsAPIUsbInit(const char *pgm, CyAsDeviceHandle h, CyAsHalDeviceTag tag)

{

    CyAsReturnStatus_t ret ;

    /*char buffer[16] ;*/

	g_tag = tag ;

	memset(g_pAstDevice,0, sizeof(g_AstDevice));

	g_pAstDevice->astHalTag = tag ;

	g_pAstDevice->astDevHandle = h ;

    /*

    * Give a delay to allow any equipment to be ready (e.g. CATC)

    */

    /*CyAsHalPrintMessage("Press enter to begin USB operation (%s): ", "P Port Enumeration") ;

    fgets(buffer, sizeof(buffer), stdin) ;*/

	CyAsHalPrintMessage("*** CyAsStorageStart...\n") ;

    ret = CyAsStorageStart(h, 0, 0) ;

    if (ret != CY_AS_ERROR_SUCCESS)

    {

        CyAsHalPrintMessage("%s: CyAsStorageStart returned error code %d\n", pgm, ret) ;

        return 0 ;

    }

    CyAsHalPrintMessage("*** CyAsStorageStart...Done\n") ;

    /*

    * Register a storage event call-back so that the USB attached storage can be

    * release when the USB connection has been made.

    */

    CyAsHalPrintMessage("*** CyAsStorageRegisterCallback...\n") ;

    ret = CyAsStorageRegisterCallback(h, MyStorageEventCBMS) ;

    if (ret != CY_AS_ERROR_SUCCESS)

    {

        CyAsHalPrintMessage("%s: CyAsStorageRegisterCallbackMS returned error code %d\n", pgm, ret) ;

        return 0 ;

    }

    CyAsHalPrintMessage("*** CyAsStorageRegisterCallback...Done\n") ;

	ret = CyAsStorageRelease(h, 1, 0, 0, 0) ;

	if (ret != CY_AS_ERROR_SUCCESS)

	{

		CyAsHalPrintMessage("CyAsStorageReleaseMS returned error code %d\n", ret) ;

		return 0 ;

	}

	gStorageReleaseBus1 = CyFalse ;

    /*

     * Use the 24 MHz operating frequency, if the SD card is a low speed one.

     */

    ret = CyAsMiscSetLowSpeedSDFreq(h, CY_AS_SD_RATED_FREQ, 0, 0) ;

    if ((ret != CY_AS_ERROR_SUCCESS) && (ret != CY_AS_ERROR_INVALID_RESPONSE))

    {

        CyAsHalPrintMessage("%s: CyAsMiscSetLowSpeedSDFreq returned error code %d\n", pgm, ret) ;

        return 0 ;

    }

    /*

    * We are using P Port based enumeration

    */

#ifdef DEBUG_ZERO

    if (!SetupUSBPPort(h, 2, 0))

#else

    if (!SetupUSBPPort(h, 2, 1))

#endif

        return 0 ;

    /*

    * Now we let the enumeration process happen via callbacks.  When the set configuration

    * request is processed, we are done with enumeration and ready to perform our function.

    */

    while (!gSetConfig)

        CyAsHalSleep(100) ;

    CyAsHalPrintMessage("*** Configuration complete, starting echo function\n") ;

    return 1 ;

}

static void

MyCyAsMTPEventCallback(

    CyAsDeviceHandle handle,

    CyAsMTPEvent evtype,

    void* evdata)

{

	(void) handle;

	switch(evtype)

	{

	case CyAsMTPSendObjectComplete:

		{

			CyAsMTPSendObjectCompleteData* sendObjData = (CyAsMTPSendObjectCompleteData*) evdata ;

			CyAsHalPrintMessage("MTP EVENT: SendObjectComplete\n");

			CyAsHalPrintMessage("Bytes sent = %d\nSend status = %d",sendObjData->byte_count,sendObjData->status);

			g_pAstDevice->tmtpSendCompleteData.byte_count = sendObjData->byte_count;

			g_pAstDevice->tmtpSendCompleteData.status = sendObjData->status;

			g_pAstDevice->tmtpSendCompleteData.transaction_id = sendObjData->transaction_id ;

			g_pAstDevice->tmtpSendComplete = CyTrue ;

			break;

		}

	case CyAsMTPGetObjectComplete:

		{

			CyAsMTPGetObjectCompleteData*  getObjData = (CyAsMTPGetObjectCompleteData*) evdata ;

			CyAsHalPrintMessage("MTP EVENT: GetObjectComplete\n");

			CyAsHalPrintMessage("Bytes got = %d\nGet status = %d",getObjData->byte_count,getObjData->status);

			g_pAstDevice->tmtpGetCompleteData.byte_count = getObjData->byte_count;

			g_pAstDevice->tmtpGetCompleteData.status = getObjData->status ;

			g_pAstDevice->tmtpGetComplete = CyTrue ;

			break;

		}

	case CyAsMTPBlockTableNeeded:

		g_pAstDevice->tmtpNeedNewBlkTbl = CyTrue ;

		break;

	default:

		;

	}

}

/*

* This function is responsible for initializing the USB function within West Bridge.  This

* function initializes West Bridge for P port based enumeration.

*/

int SetupUSBPPort(CyAsDeviceHandle h, uint8_t bus, CyBool isTurbo)

{

    CyAsReturnStatus_t ret ;

    CyAsUsbEnumControl config ;

#ifdef DEBUG_ZERO

    CyAsUsbEndPointConfig epconfig ;

#endif

    uint32_t count = 0 ;

    CyAsHalPrintMessage("*** SetupUSBPPort...\n") ;

    /*

    * Intialize the primary descriptor to be the full speed descriptor and the

    * other descriptor to by the high speed descriptor.  This will swap if we see a

    * high speed event.

    */

#ifdef DEBUG_ZERO

    desc_p = (CyCh9ConfigurationDesc *)&ConfigFSDesc ;

    other_p = (CyCh9ConfigurationDesc *)&ConfigHSDesc ;

#else

    desc_p = (CyCh9ConfigurationDesc *)&ZeroDesc ;

    other_p = (CyCh9ConfigurationDesc *)&ZeroDesc ;

#endif

    /* Step 1: Release the USB D+ and D- pins

    *

    * This code releases control of the D+ and D- pins if they have been previously

    * acquired by the P Port processor.  The physical D+ and D- pins are controlled either by

    * West Bridge, or by some other hardware external to West Bridge.  If external hardware is using

    * these pins, West Bridge must put these pins in a high impedence state in order to insure there

    * is no coflict over the use of the pins.  Before we can initialize the USB capabilities of

    * West Bridge, we must be sure West Bridge has ownership of the D+ and D- signals.  West Bridge will take

    * ownership of these pins as long as the P port processor has released them.  This call

    * releases control of these pins.  Before calling the CyAsMiscReleaseResource(), the P port API

    * must configure the hardware to release control of the D+ and D- pins by any external hardware.

    *

    * Note that this call can be made anywhere in the intialization sequence as long as it is done

    * before the call to CyAsUsbConnect().  If not, when the CyAsUsbConnect() call is made, West Bridge

    * will detect that it does not own the D+ and D- pins and the call to CyAsUsbConnect will fail.

    */

    ret = CyAsMiscReleaseResource(h, CyAsBusUSB) ;

    if (ret != CY_AS_ERROR_SUCCESS && ret != CY_AS_ERROR_RESOURCE_NOT_OWNED)

    {

        CyAsHalPrintMessage("Cannot Release USB reousrce: CyAsMiscReleaseResourceMS failed with error code %d\n", ret) ;

        return 0 ;

    }

    /*

    * Step 2: Start the USB stack

    *

    * This code initializes the USB stack.  It takes a handle to an West Bridge device

    * previously created with a call to CyAsMiscCreateDevice().

    */

    ret = CyAsUsbStart(h, 0, 0) ;

    if (ret != CY_AS_ERROR_SUCCESS)

    {

        CyAsHalPrintMessage("CyAsUsbStart failed with error code %d\n", ret) ;

        return 0 ;

    }

    /*

    * Step 3: Register a callback

    *

    * This code registers a callback to handle USB events.  This callback function will handle

    * all setup packets during enumeration as well as other USB events (SUSPEND, RESUME, CONNECT,

    * DISCONNECT, etc.)

    */

    ret = CyAsUsbRegisterCallback(h, MyUsbEventCallbackMS) ;

    if (ret != CY_AS_ERROR_SUCCESS)

    {

        CyAsHalPrintMessage("CyAsUsbRegisterCallbackMS failed with error code %d\n", ret) ;

        return 0 ;

    }

#ifdef DEBUG_ZERO

    if ( isTurbo )

#endif

    {

		/*

		 * The SD/MMC resource needs to be released before the device

		 * can be successfully initialized by the firmware.

		 */

		ret = CyAsMiscReleaseResource(h, CyAsBus_1) ;

		if (ret != CY_AS_ERROR_SUCCESS && ret != CY_AS_ERROR_RESOURCE_NOT_OWNED)

		{

			CyAsHalPrintMessage("CyAsMtpApp: CyAsMiscReleaseResource failed with error code %d\n", ret) ;

			return -ret;

		}

		ret = CyAsStorageStart(h, 0, 0) ;

		if (ret != CY_AS_ERROR_SUCCESS)

		{

			CyAsHalPrintMessage("CyAsMtpApp: CyAsStorageStart failed with error code %d\n", ret) ;

			return -ret;

		}

		ret = CyAsStorageQueryMedia(h, CyAsMediaSDFlash, &count, 0, 0) ;

		if (ret != CY_AS_ERROR_SUCCESS)

		{

		  return -ret ;

		}

		CyAsHalPrintMessage("CyAsMtpApp: %d %s device(s) found\n", count, media_name) ;

		ret = CyAsStorageClaim(h, CyAsBus_1, 0, 0, 0) ;

		if (ret != CY_AS_ERROR_SUCCESS)

		{

		  return -ret;

		}

		/* We know that there is only one */

		g_pAstDevice->dev_data.bus = CyAsBus_1 ;

		g_pAstDevice->dev_data.device = 0 ;

		ret = CyAsStorageQueryDevice(h, &(g_pAstDevice->dev_data), 0, 0) ;

		if (ret != CY_AS_ERROR_SUCCESS)

		{

		  return -ret ;

		}

		CyAsHalPrintMessage("CyAsMtpApp: blocksize %d, %d units found\n",

			g_pAstDevice->dev_data.desc_p.block_size, g_pAstDevice->dev_data.desc_p.number_units) ;

		g_pAstDevice->unit_data.bus = CyAsBus_1 ;

		g_pAstDevice->unit_data.device = 0 ;

		g_pAstDevice->unit_data.unit = 0 ;

		/* We know that there is only one */

		ret = CyAsStorageQueryUnit(h, &(g_pAstDevice->unit_data), 0, 0) ;

		if (ret != CY_AS_ERROR_SUCCESS)

		{

		  return -ret ;

		}

		CyAsHalPrintMessage("CyAsMtpApp: blocksize %d, %d Block(s) found\n",

			g_pAstDevice->unit_data.desc_p.block_size, g_pAstDevice->unit_data.desc_p.unit_size) ;

			CyAsHalPrintMessage("CyAsMtpApp: Starting TMTP...\n");

		ret = CyAsMTPStart(h, MyCyAsMTPEventCallback, 0, 0) ;

		if (ret != CY_AS_ERROR_SUCCESS)

		{

			CyAsHalPrintMessage("CyAsMTPStart failed with error code %d\n", ret) ;

			return 0 ;

		}

    }

    /*

    * Step 4: Setup the enumeration mode

    *

    * This code tells the West Bridge API how enumeration will be done.  Specifically in this

    * example we are configuring the API for P Port processor based enumeraton.  This will cause

    * all setup packets to be relayed to the P port processor via the USB event callback.  See

    * the function CyAsUsbRegisterEventCallback() for more information about this callback.

    */

    config.antioch_enumeration = CyFalse ;                      /* P port will do enumeration, not West Bridge */

    /* Set the media to enumerate through USB */

#ifdef DEBUG_ZERO

    config.devices_to_enumerate[0][0] = CyFalse;

    config.devices_to_enumerate[1][0] = CyFalse;

#else

    config.devices_to_enumerate[0][0] = (bus & CY_TEST_BUS_0) ? CyTrue : CyFalse;

    config.devices_to_enumerate[1][0] = (bus & CY_TEST_BUS_1) ? CyTrue : CyFalse;

#endif

    if (isTurbo)

    {

        /* Force SD bus */

        config.devices_to_enumerate[0][0] = CyFalse;

        config.devices_to_enumerate[1][0] =  CyTrue ;

        /* No MSC in Turbo */

        config.mass_storage_interface = 0 ;

        config.mtp_interface = 1 ;

    }

    else

    {

        /* not Turbo here */

        config.mtp_interface = 0 ;

#ifndef DEBUG_MSC

        config.mass_storage_interface = 0 ;

        config.mass_storage_callbacks = CyFalse ;

#else

        /* Force SD bus */

        config.devices_to_enumerate[1][0] =  CyTrue ;

        config.mass_storage_interface = 1 ;

        config.mass_storage_callbacks = CyTrue ;

#endif

    }

    ret = CyAsUsbSetEnumConfig(h, &config, 0, 0) ;

    if (ret != CY_AS_ERROR_SUCCESS)

    {

        CyAsHalPrintMessage("CyAsUsbSetEnumConfigMS failed with error code %d\n", ret) ;

        return 0 ;

    }

#ifndef DEBUG_MSC

    /*

     * Step 5: set physical configuration

     */

#ifdef DEBUG_ZERO

    /*nxz-debug-z ret = CyAsUsbSetPhysicalConfiguration(h, 5) ;*/

    ret = CyAsUsbSetPhysicalConfiguration(h, 1) ;

#else

    ret = CyAsUsbSetPhysicalConfiguration(h, 5) ;

#endif

    if (ret != CY_AS_ERROR_SUCCESS)

    {

        CyAsHalPrintMessage("CyAsUsbSetPhysicalConfiguration failed with error code %d\n", ret) ;

        return 0 ;

    }

    /*

    * Step 5: Commit the endpoint configuration

    */

#ifdef DEBUG_ZERO

    epconfig.enabled = CyTrue ;

    epconfig.dir = CyAsUsbOut ;

    epconfig.type = CyAsUsbBulk ;

    epconfig.size = 0 ;

    epconfig.physical = 1 ;

    ret = CyAsUsbSetEndPointConfig(h, 3, &epconfig) ;

    if ( ret != CY_AS_ERROR_SUCCESS )

    {

	CyAsHalPrintMessage("CyAsUsbSetEndPointConfig failed with error code %d\n", ret) ;

        return 0 ;

    }

    epconfig.enabled = CyTrue ;

    epconfig.dir = CyAsUsbIn ;

    epconfig.type = CyAsUsbBulk ;

    epconfig.size = 0 ;

    epconfig.physical = 3 ;

    ret = CyAsUsbSetEndPointConfig(h, 5, &epconfig) ;

    if ( ret != CY_AS_ERROR_SUCCESS )

    {

	CyAsHalPrintMessage("CyAsUsbSetEndPointConfig failed with error code %d\n", ret) ;

        return 0 ;

    }

    /*nxz-debug-z */

    epconfig.enabled = CyTrue ;

    epconfig.dir = CyAsUsbIn ;

    epconfig.type = CyAsUsbInt ;

    epconfig.size = 64 ;

    epconfig.physical = 2 ;

    ret = CyAsUsbSetEndPointConfig(h, 7, &epconfig) ;

    if ( ret != CY_AS_ERROR_SUCCESS )

    {