/* Cypress West Bridge API source file 

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

##

##  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 "locmedia.h"

#include "platform.h"

//#include "variantmediadef.h"

#include <assp\omap3530_assp\CyAsSymbianStorageDriver.h>

//#define REGIST_MEDIA_USE_MMC

#define _MEDWB_DEBUG_1_

//#define _MEDWB_DEBUG_2_

//#define INTERVAL_FOR_WB 15 // 15 -- OK

#define WB_BUFFER_SIZE	2*(65536 + 512)

#define WB_RETRY_COUNT 2

//const TInt KStackNumber = 0;

const TInt KDiskSectorSize=512;

const TInt KDiskSectorShift=9;

//const TInt KIdleCurrentInMilliAmps = 1;

const TInt KMBRFirstPartitionEntry=0x1BE;

TUint8	ptrWBBuffer[WB_BUFFER_SIZE];

template <class T>

inline T UMin(T aLeft,T aRight)

	{return(aLeft<aRight ? aLeft : aRight);}

class DPhysicalDeviceMediaWB : public DPhysicalDevice

	{

public:

	DPhysicalDeviceMediaWB();

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DBase*& aChannel, TInt aMediaId, const TDesC8* aInfo, const TVersion& aVer);

	virtual TInt Validate(TInt aDeviceType, const TDesC8* aInfo, const TVersion& aVer);

	virtual TInt Info(TInt aFunction, TAny* a1);

	};

class DMediaDriverWB : public DMediaDriver

	{

public:

	DMediaDriverWB(TInt aMediaId);

	~DMediaDriverWB();

	// ...from DMediaDriver

	virtual void Close();

	// replacing pure virtual

	virtual void Disconnect(DLocalDrive* aLocalDrive, TThreadMessage*);

	virtual TInt Request(TLocDrvRequest& aRequest);

	virtual TInt PartitionInfo(TPartitionInfo& anInfo);

	virtual void NotifyPowerDown();

	virtual void NotifyEmergencyPowerDown();

	// For creation by DPhysicalDeviceMediaMmcFlash

	TInt DoCreate(TInt aMediaId);

private:

private:

	// MMC device specific stuff

	TInt DoRead(TLocDrvRequest&);

	TInt DoWrite(TLocDrvRequest&);

	TInt DoFormat(TLocDrvRequest&);

	TInt Caps(TLocDrv& aDrive, TLocalDriveCapsV6& aInfo);

	TInt DecodePartitionInfo();

	TInt WritePartitionInfo();

	TInt GetDefaultPartitionInfo(TMBRPartitionEntry& aPartitionEntry);

	TInt CreateDefaultPartition();

	static void SetPartitionEntry(TPartitionEntry* aEntry, TUint aFirstSector, TUint aNumSectors);

	TInt CheckDevice(int aReqType);

	void Reset();

private:

	TInt iMediaId;

	TPartitionInfo* iPartitionInfo;

	TBool iMbrMissing;

	TUint iHiddenSectors;						// bootup / password

	TUint8* ptrWriteBuf;							// start of current buffer region

	TUint8* ptrReadBuf;							// start of current buffer region

	TInt	read_size;

	TInt	read_pos;

	TInt 	iUnitSize;

	TInt	iBlockSize;

	};

// ======== DPhysicalDeviceMediaMmcFlash ========

DPhysicalDeviceMediaWB::DPhysicalDeviceMediaWB()

	{

	#ifdef _MEDWB_DEBUG_3_

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

	#endif

	iUnitsMask = 0x01;

	iVersion = TVersion(KMediaDriverInterfaceMajorVersion,KMediaDriverInterfaceMinorVersion,KMediaDriverInterfaceBuildVersion);

	}

TInt DPhysicalDeviceMediaWB::Install()

	{

	#ifdef _MEDWB_DEBUG_3_

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

	#endif

	_LIT(KDrvNm, "Media.WB");

	return SetName(&KDrvNm);

	}

void DPhysicalDeviceMediaWB::GetCaps(TDes8& /* aDes */) const

	{

	#ifdef _MEDWB_DEBUG_3_

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

	#endif

	}

TInt DPhysicalDeviceMediaWB::Info(TInt aFunction, TAny* /*a1*/)

//

// Return the priority of this media driver

//

	{

	#ifdef _MEDWB_DEBUG_3_

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

	#endif

	if (aFunction==EPriority)

		return KMediaDriverPriorityNormal;

	// Don't close media driver when peripheral bus powers down. This avoids the need for Caps() to power up the stack.

	if (aFunction==EMediaDriverPersistent)

		return KErrNone;

	return KErrNotSupported;

	}

TInt DPhysicalDeviceMediaWB::Validate(TInt aDeviceType, const TDesC8* /*aInfo*/, const TVersion& aVer)

	{

	#ifdef _MEDWB_DEBUG_3_

	Kern::Printf("=mmd:validate aDeviceType %d\n", aDeviceType);

	#endif

	if (!Kern::QueryVersionSupported(iVersion,aVer))

	{	

	#ifdef _MEDWB_DEBUG_3_

		Kern::Printf("Validate -> KErrNotSupported\n");

	#endif

		return KErrNotSupported;

	}

	if (aDeviceType!=MEDIA_DEVICE_MMC)

	{

	#ifdef _MEDWB_DEBUG_3_

		Kern::Printf("Validate -> Wrong DeviceType\n");

	#endif

		return KErrNotSupported;

	}

	return KErrNone;

	}

TInt DPhysicalDeviceMediaWB::Create(DBase*& aChannel, TInt aMediaId, const TDesC8* /*aInfo*/, const TVersion& aVer)

//

// Create an MMC Card media driver.

//

	{

	#ifdef _MEDWB_DEBUG_3_

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

	#endif

	if (!Kern::QueryVersionSupported(iVersion,aVer))

		return KErrNotSupported;

	DMediaDriverWB* pD = new DMediaDriverWB(aMediaId);

	aChannel=pD;

	TInt r=KErrNoMemory;

	if (pD)

		r=pD->DoCreate(aMediaId);

	#ifdef REGIST_MEDIA_USE_MMC

	if (r==KErrNone)

		pD->OpenMediaDriverComplete(KErrNone);

	#endif

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("<mmd:mdf"));

	return r;

	}

// Helper

template <class T>

inline T* KernAlloc(const TUint32 n)

	{ return static_cast<T*>(Kern::Alloc(n * sizeof(T))); }

// ---- ctor, open, close, dtor ----

#pragma warning( disable : 4355 )	// this used in initializer list

DMediaDriverWB::DMediaDriverWB(TInt aMediaId)

   :DMediaDriver(aMediaId),

	iMediaId(iPrimaryMedia->iNextMediaId)

	{

	#ifdef _MEDWB_DEBUG_2_

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

	// NB aMedia Id = the media ID of the primary media, iMediaId = the media ID of this media

	Kern::Printf("DMediaDriverWB(), iMediaId %d, aMediaId %d\n", iMediaId, aMediaId);

	#endif

	}

#pragma warning( default : 4355 )

TInt DMediaDriverWB::DoCreate(TInt /*aMediaId*/)

	{

	#ifdef _MEDWB_DEBUG_3_

	Kern::Printf(">mmd:opn");

	#endif

	iUnitSize = CyAsSymbianStorageDriver::GetUnitSize();

	iBlockSize = CyAsSymbianStorageDriver::GetBlockSize();

	if( iBlockSize == 0 )

		iBlockSize = 1;

	read_pos = 0x7FFFFFFF;

	read_size = 0;

	// get card characteristics

	SetTotalSizeInBytes(CyAsSymbianStorageDriver::GetMediaSize());

	// get buffer memory from EPBUS

	ptrReadBuf = ptrWBBuffer;

	ptrWriteBuf = &ptrWBBuffer[65536+512];

	#ifdef _MEDWB_DEBUG_3_

	Kern::Printf("<mmd:opn");

	#endif

	return(KErrNone);

	}

void DMediaDriverWB::Close()

//

// Close the media driver - also called on media change

//

	{

	#ifdef _MEDWB_DEBUG_3_

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

	#endif

	EndInCritical();

	//CompleteRequest(KErrNotReady);

	DMediaDriver::Close();

	}

DMediaDriverWB::~DMediaDriverWB()

	{

	}

// ---- media access ----

TInt DMediaDriverWB::DoRead(TLocDrvRequest& iCurrentReq)

//

// set up iReqStart, iReqEnd and iReqCur and launch first read.  Subsequent reads

// will be launched from the callback DFC.

//

	{

	Int64 pos=iCurrentReq.Pos();

	Int64 length=iCurrentReq.Length();

	TInt r;

	if (length<0 || pos<0 || (pos+length)>KMaxTInt)

		return KErrGeneral;

	TInt p=(TInt)pos;

	TInt l=(TInt)length;

	if (p+l>CyAsSymbianStorageDriver::GetMediaSize())

		return KErrGeneral;

	TInt pos_block = p / iBlockSize;

	TInt pos_offset =  p % iBlockSize;

	TInt size_block = l / iBlockSize; 

	TInt size_offset = l % iBlockSize; 

	TUint buf_offset = 0;

	TInt	local_pos;

	#ifdef _MEDWB_DEBUG_2_

	Kern::Printf("WB::Read> real (%d@%d)", l, p);

	Kern::Printf("WB::Read> pos_block - %d", pos_block) ;

	Kern::Printf("WB::Read> pos_offset - %d", pos_offset) ;

	Kern::Printf("WB::Read> size_block - %d", size_block) ;

	Kern::Printf("WB::Read> size_offset - %d", size_offset) ;

	#endif

	#ifdef INTERVAL_FOR_WB

	NKern::Sleep(INTERVAL_FOR_WB);

	#endif

	if( pos_block == read_pos )

	{

		if( read_size < l )

		{

			buf_offset = read_size;

			size_block = (l-read_size) / iBlockSize;

			size_offset = (l-read_size) % iBlockSize;

			local_pos = pos_block + (read_size /iBlockSize);

		}

		else

		{

			TPtrC8 des((ptrReadBuf+pos_offset), l);

			r = iCurrentReq.WriteRemote(&des, 0);

			return r;

		}

	}

	#if 0

	else if( (read_pos + (read_size/iBlockSize)) > pos_block )

	{

		TInt adjust_offset;

		TInt adjust_size;

		adjust_offset = (read_pos - pos_block) * iBlockSize;

		adjust_size = read_size - adjust_offset;

		memcpy(ptrReadBuf, &ptrReadBuf[adjust_offset], adjust_size );

		read_pos = pos_block;

		read_size = adjust_size;

		if( read_size < l )

		{

			buf_offset = read_size;

			size_block = (l-read_size) / iBlockSize;

			size_offset = (l-read_size) % iBlockSize;

			local_pos = pos_block + (read_size /iBlockSize);

		}

		else

		{

			TPtrC8 des((ptrReadBuf+pos_offset), l);

			r = iCurrentReq.WriteRemote(&des, 0);

			return r;

		}

	}

	#endif

	else

		local_pos = read_pos = pos_block;

	#ifdef _MEDWB_DEBUG_2_

	Kern::Printf("WB::Read> local_pos - %d", local_pos) ;

	Kern::Printf("WB::Read> buf_offset - %d", buf_offset) ;

	#endif

	if( size_block )

	{

		CyAsSymbianStorageDriver::Read(local_pos, size_block, (void *)(ptrReadBuf+buf_offset));

		local_pos += size_block;

		buf_offset += (size_block*iBlockSize);

	#ifdef INTERVAL_FOR_WB

		NKern::Sleep(INTERVAL_FOR_WB);

	#endif

	}

	if( pos_offset || size_offset )

	{

		CyAsSymbianStorageDriver::Read(local_pos, 1, (void *)(ptrReadBuf+buf_offset) );

		local_pos += size_block;

		buf_offset += iBlockSize;

	#ifdef INTERVAL_FOR_WB

		NKern::Sleep(INTERVAL_FOR_WB);

	#endif

	}

	read_size = buf_offset;

	TPtrC8 des((ptrReadBuf+pos_offset), l);

	r = iCurrentReq.WriteRemote(&des, 0);

	return r;

	}

TInt DMediaDriverWB::DoWrite(TLocDrvRequest& iCurrentReq)

//

// set up iReqStart, iReqEnd, and iReqCur, and launch first write.  Any subsequent

// writes are launched from the session end DFC.  LaunchWrite() handles pre-reading

// any sectors that are only partially modified.

//

	{

	Int64 pos = iCurrentReq.Pos();

	Int64 length = iCurrentReq.Length();

	TInt r;

	if (length<0 || pos<0 || (pos+length)>KMaxTInt)

		return KErrGeneral;

	TInt p=(TInt)pos;

	TInt l=(TInt)length;

	if (p+l>CyAsSymbianStorageDriver::GetMediaSize())

		return KErrGeneral;

	#ifdef _MEDWB_DEBUG_2_

	Kern::Printf("WB::Write> (%d@%d)", l, p);

	#endif

	#ifdef INTERVAL_FOR_WB

	NKern::Sleep(INTERVAL_FOR_WB);

	#endif

	TInt pos_block = p / iBlockSize;

	TInt pos_offset =  p % iBlockSize;

	TInt size_block = l / iBlockSize; 

	TInt size_offset = l % iBlockSize; 

	TUint buf_offset = 0;

	TInt	local_pos;

	TInt	w_block_size = 0;

	local_pos = pos_block;

	if( size_block )

	{

		CyAsSymbianStorageDriver::Read(local_pos, size_block, (void *)(ptrWriteBuf+buf_offset));

		local_pos += size_block;

		buf_offset += (size_block*iBlockSize);

		w_block_size += size_block;

	#ifdef INTERVAL_FOR_WB

		NKern::Sleep(INTERVAL_FOR_WB);

	#endif

	}

	if( pos_offset || size_offset )

	{

		CyAsSymbianStorageDriver::Read(local_pos, 1, (void *)(ptrWriteBuf+buf_offset) );

		local_pos += size_block;

		buf_offset += iBlockSize;

		w_block_size ++;

	#ifdef INTERVAL_FOR_WB

		NKern::Sleep(INTERVAL_FOR_WB);

	#endif

	}

	#ifdef _MEDWB_DEBUG_2_

	Kern::Printf("WB::Write> pos_block - %d", pos_block) ;

	Kern::Printf("WB::Write> pos_offset - %d", pos_offset) ;

	Kern::Printf("WB::Write> size_block - %d", size_block) ;

	Kern::Printf("WB::Write> size_offset - %d", size_offset) ;

	#endif

	TPtr8 des((ptrWriteBuf+pos_offset), l);

	if ( (r = iCurrentReq.ReadRemote(&des,0)) !=KErrNone)

	{

		return r;			

	}

	#ifdef _MEDWB_DEBUG_2_

	Kern::Printf("WB::Write> local_pos - %d", local_pos) ;

	Kern::Printf("WB::Write> w_block_size - %d", w_block_size) ;

	#endif

	CyAsSymbianStorageDriver::Write(local_pos, w_block_size, ptrWriteBuf);

	#ifdef INTERVAL_FOR_WB

	NKern::Sleep(INTERVAL_FOR_WB);

	#endif

	return r;

	}

TInt DMediaDriverWB::DoFormat(TLocDrvRequest& iCurrentReq)

	{

	Int64 pos = iCurrentReq.Pos();

	Int64 length = iCurrentReq.Length();

	TInt r;

	if (length<0 || pos<0 || (pos+length)>KMaxTInt)

		return KErrGeneral;

	TInt p=(TInt)pos;

	TInt l=(TInt)length;

	if (p+l>CyAsSymbianStorageDriver::GetMediaSize())

		return KErrGeneral;

	#ifdef _MEDWB_DEBUG_1_

	Kern::Printf("WB::Format> (%d@%d)", l, p);

	#endif

	#ifdef INTERVAL_FOR_WB

	NKern::Sleep(INTERVAL_FOR_WB);

	#endif

	TInt pos_block = p / iBlockSize;

	TInt pos_offset =  p % iBlockSize;

	TInt size_block = l / iBlockSize; 

	TInt size_offset = l % iBlockSize; 

	TUint buf_offset = 0;

	TInt	local_pos;

	TInt	w_block_size = 0;

	local_pos = pos_block;

	if( size_block )

	{

		CyAsSymbianStorageDriver::Read(local_pos, size_block, (void *)(ptrWriteBuf+buf_offset));

		local_pos += size_block;

		buf_offset += (size_block*iBlockSize);