#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>

#include "CyAsSymbianStorageDriver.h"

extern TmtpAstDev g_AstDevice;

extern TmtpAstDev * g_pAstDevice;

_LIT(KLitWbAPIMutex,"WBAPIMutex");

static DMutex	*WbApiMutex;

const TUint8 KMutexOrdWB			= 0x11; /**< @internalComponent */

TInt64	iMediaTotalSize;

EXPORT_C int  CyAsSymbianStorageDriver::Open(void)

{

	//CyAsHalDeviceTag          tag;

	CyAsDeviceHandle          h;

	CyAsReturnStatus_t ret ;

	char *media_name = "SD";

	uint32_t count = 0 ;

	Kern::MutexCreate(WbApiMutex, KLitWbAPIMutex, KMutexOrdWB);

	//tag = g_pAstDevice->astHalTag ;

	h = g_pAstDevice->astDevHandle ;

    Kern::Printf("*** CyAsStorageStart...\n") ;

    ret = CyAsStorageStart(h, 0, 0) ;

    if (ret != CY_AS_ERROR_SUCCESS)

    {

        Kern::Printf("CyAsSymbianStorageOpen: CyAsStorageStart returned error code %d\n", ret) ;

        return 0 ;

    }

	Kern::Printf("*** CyAsStorageQueryMedia...\n") ;

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

	if (ret != CY_AS_ERROR_SUCCESS)

	{

	  Kern::Printf("CyAsSymbianStorageOpen: Cannot query %s device count - Reason code %d\n", media_name, ret) ;

	  return 0 ;

	}

	Kern::Printf("%d %s device(s) found\n", count, media_name) ;

	Kern::Printf("*** CyAsStorageClaim...\n") ;

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

	if (ret != CY_AS_ERROR_SUCCESS)

	{

	  Kern::Printf("CyAsSymbianStorageOpen: Cannot claim %s media - Reason code %d\n", media_name, ret) ;

	  return 0;

	}

	/* 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)

	{

	  Kern::Printf("CyAsSymbianStorageOpen: Cannot query %s device - Reason code %d\n", media_name, ret) ;

	  return 0 ;

	}

	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)

	{

	  Kern::Printf("CyAsSymbianStorageOpen: Cannot query %s device unit - Reason code %d\n", media_name, ret) ;

	  return 0 ;

	}

	iMediaTotalSize = (TInt64)g_pAstDevice->dev_data.desc_p.block_size * (TInt64)g_pAstDevice->unit_data.desc_p.unit_size;

#if 0

	Kern::Printf("========================================================") ;

	Kern::Printf("WBStorageInfo.type - %d", g_pAstDevice->dev_data.desc_p.type) ;

	Kern::Printf("WBStorageInfo.removable - %d", g_pAstDevice->dev_data.desc_p.removable) ;

	Kern::Printf("WBStorageInfo.writeable - %d", g_pAstDevice->dev_data.desc_p.writeable) ;

	Kern::Printf("WBStorageInfo.block_size - %d Bytes", g_pAstDevice->dev_data.desc_p.block_size) ;

	Kern::Printf("WBStorageInfo.number_units - %d", g_pAstDevice->dev_data.desc_p.number_units) ;

	Kern::Printf("WBStorageInfo.locked - %d", g_pAstDevice->dev_data.desc_p.locked) ;

	Kern::Printf("WBStorageInfo.erase_unit_size - %d Bytes", g_pAstDevice->dev_data.desc_p.erase_unit_size) ;

	Kern::Printf("WBStorageInfo.unit_size - %d", g_pAstDevice->unit_data.desc_p.unit_size) ;

	Kern::Printf("WBStorageInfo.start_block - %d", g_pAstDevice->unit_data.desc_p.start_block) ;

	Kern::Printf("WBStorageInfo.totalsize - %d Bytes", iMediaTotalSize) ;

	Kern::Printf("========================================================\n") ;

#endif

	return 1;

}

EXPORT_C int CyAsSymbianStorageDriver::Close(void)

{

	CyAsDeviceHandle          h;

	CyAsReturnStatus_t ret ;

	//tag = g_pAstDevice->astHalTag ;

	h = g_pAstDevice->astDevHandle ;

    Kern::Printf("*** CyAsStorageStop...\n") ;

    ret = CyAsStorageStop(h, 0, 0) ;

    if (ret != CY_AS_ERROR_SUCCESS)

    {

        Kern::Printf("CyAsStorageStop: CyAsStorageStop returned error code %d\n", ret) ;

        return 0 ;

    }

	return 1;

}

EXPORT_C int CyAsSymbianStorageDriver::Read(int	pos, int num_block, void* cybuf)

{

	//CyAsHalDeviceTag          tag;

	CyAsDeviceHandle          h;

	CyAsReturnStatus_t ret ;

	char *tmpbuf;

	Kern::MutexWait(*WbApiMutex); 

	tmpbuf = (char *)cybuf;

	//tag = g_pAstDevice->astHalTag ;

	h = g_pAstDevice->astDevHandle ;

	//CyAsHalPrintMessage("Read SD card\n");

	ret = CyAsStorageRead(	h, 1, 0, 0, pos, tmpbuf, num_block);

	if (ret != CY_AS_ERROR_SUCCESS)

	{

		Kern::Printf("CyAsSymbianStorageRead: Cannot read sector %d (%d@%d)\n", ret, num_block, pos) ;

		return 0 ;

	}

	Kern::MutexSignal(*WbApiMutex); 

	return 1;

}

EXPORT_C int CyAsSymbianStorageDriver::Write(int pos, int num_block, void* cybuf)

{

	//CyAsHalDeviceTag          tag;

	CyAsDeviceHandle          h;

	CyAsReturnStatus_t ret ;

	char *tmpbuf;

	Kern::MutexWait(*WbApiMutex); 

	tmpbuf = (char *)cybuf;

	//tag = g_pAstDevice->astHalTag ;

	h = g_pAstDevice->astDevHandle ;

	ret = CyAsStorageWrite(h, 1, 0, 0, pos, tmpbuf, num_block);

	if ( ret != CY_AS_ERROR_SUCCESS )

	{

		Kern::Printf("CyAsSymbianStorageWrite: Cannot write to first sector of SD card\n") ;

		return 0 ;

	}

	Kern::MutexSignal(*WbApiMutex); 

	return 1;

}

EXPORT_C TInt CyAsSymbianStorageDriver::GetMediaType(void)

{

	/* Type of device */

	return (TInt)g_pAstDevice->dev_data.desc_p.type;

}

EXPORT_C TInt CyAsSymbianStorageDriver::GetIsRemovable(void)

{

	/* Is the device removable */

	return g_pAstDevice->dev_data.desc_p.removable;

}

EXPORT_C TInt CyAsSymbianStorageDriver::GetIsWriteable(void)

{

	/* Is the device writeable */

	return g_pAstDevice->dev_data.desc_p.writeable;

}

EXPORT_C TUint16 CyAsSymbianStorageDriver::GetBlockSize(void)

{

	/* Basic block size for device */

	return g_pAstDevice->dev_data.desc_p.block_size;

}

EXPORT_C TUint CyAsSymbianStorageDriver::GetNumberOfUnits(void)

{

	/* Number of LUNs on the device */

	return g_pAstDevice->dev_data.desc_p.number_units;

}

EXPORT_C TInt CyAsSymbianStorageDriver::GetIsLocked(void)

{

	/* Is the device password locked */

	return g_pAstDevice->dev_data.desc_p.locked;

}

EXPORT_C TUint CyAsSymbianStorageDriver::GetEraseBlockSize(void)

{

		/* Size in bytes of an Erase Unit. Block erase operation is only supported for SD storage, 

                    and the erase_unit_size is invalid for all other kinds of storage. */

	return g_pAstDevice->dev_data.desc_p.erase_unit_size;

}

EXPORT_C TUint CyAsSymbianStorageDriver::GetUnitSize(void)

{

	/* Number of blocks in the LUN */

	return g_pAstDevice->unit_data.desc_p.unit_size;

}

EXPORT_C TUint CyAsSymbianStorageDriver::GetStartBlock(void)

{

	/* Physical start block for LUN */

	return g_pAstDevice->unit_data.desc_p.start_block;

}

EXPORT_C TInt64 CyAsSymbianStorageDriver::GetMediaSize(void)

{

	/*(Basic block size for device x  Number of LUNs on the device)  

	g_pAstDevice->dev_data.desc_p.block_size * g_pAstDevice->dev_data.desc_p.number_units */

	return iMediaTotalSize;

}