// Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// PP_MMC.CPP

// 

//

#include "plat_priv.h"

#include <property.h>

#include "variant.h"

#include "variantmediadef.h"

#include "mmci.h" 

//#define  __CARD0_NOT_LOCKABLE__

//#define  __CARD1_NOT_LOCKABLE__

const TInt  KDiskSectorSize=512;

TInt  DWinsMMCStack::TotalMDiskSize=0;		///< mmc card size for emulator

TUint DWinsMMCStack::CSIZE=0;				///< mmc card size field

TUint DWinsMMCStack::CSIZE_MULT=0;			///< mmc card size field

TInt  DWinsMMCStack::TotalWinsMMC_CardSlots = KDefault_TotalWinsCardSlots; ///< total number of MMC card slots for the emulator

TInt  DWinsMMCStack::TotalWinsMMC_Cards     = KDefault_TotalWinsCards;     ///< total number of MMC cards for the emulator

const TUint32 KCsdStructure = 0x01;	/* CSD Version No 1.1 */

const TUint32 KCsdSpecVers  = 0x03;	/* Version 3.1 */

TInt MapLastErrorEpoc()

//

// Map an NT error to an Epoc/32 error.

//

	{

	TInt res=KErrGeneral;

	switch (GetLastError())

		{

		case ERROR_SHARING_VIOLATION : res=KErrAccessDenied; break;

		case ERROR_LOCK_VIOLATION : res=KErrLocked; break;

		case ERROR_FILE_NOT_FOUND: res=KErrNotFound; break;

		case ERROR_PATH_NOT_FOUND: res=KErrPathNotFound; break;

		case ERROR_ALREADY_EXISTS:

		case ERROR_FILE_EXISTS:

			res=KErrAlreadyExists;

			break;

		case ERROR_NOT_READY: res=KErrNotReady; break;

		case ERROR_UNRECOGNIZED_VOLUME:

		case ERROR_NOT_DOS_DISK:

			res=KErrUnknown;

			break;

		case ERROR_UNRECOGNIZED_MEDIA: res=KErrCorrupt; break;

		case ERROR_INVALID_NAME: res=KErrBadName; break;

		case ERROR_NO_MORE_FILES: res=KErrEof; break;

		}

	return(res);

	}

TMMCErr MapLastErrorMmc()

//

// Map an NT error to a TMMCErr error.

//

	{

	DWORD r=GetLastError();

	TInt res=KErrGeneral;

	switch (r)

		{

		case ERROR_SHARING_VIOLATION:

		case ERROR_LOCK_VIOLATION:

			res=KMMCErrLocked;			// KErrLocked

			break;

		case ERROR_FILE_NOT_FOUND:

		case ERROR_PATH_NOT_FOUND:

			res=KMMCErrNotFound;		// KErrNotFound

			break;

		case ERROR_ALREADY_EXISTS:

		case ERROR_FILE_EXISTS:

			res=KMMCErrAlreadyExists;	// KErrAlreadyExists

			break;

		case ERROR_NOT_READY: res=KMMCErrNoCard; break;

		case ERROR_UNRECOGNIZED_VOLUME:

		case ERROR_NOT_DOS_DISK:

			res=KMMCErrGeneral;			// KErrGeneral

			break;

		case ERROR_UNRECOGNIZED_MEDIA:

		case ERROR_INVALID_NAME:

		case ERROR_NO_MORE_FILES:

			res=KMMCErrResponseCRC; 	// KErrCorrupt

			break;

		}

	return(res);

	}

void DWinsMMCStack::MachineInfo(TMMCMachineInfo& aMachineInfo)

//

// Return machine info relating to this MultiMediaCard Stack

//

	{

	aMachineInfo.iTotalSockets=TotalWinsMMC_CardSlots;

	aMachineInfo.iTotalMediaChanges=0;  		// Not used at present

	aMachineInfo.iTotalPrimarySupplies=0;		// Not used at present

	aMachineInfo.iFlags = TMMCMachineInfo::ESupportsDoubleBuffering;

    aMachineInfo.iBaseBusNumber=0;

	__KTRACE_OPT(KPBUS1,Kern::Printf("<WinsMMC:MachineInfo"));

	__KTRACE_OPT(KPBUS1,Kern::Printf(" %d stacks",aMachineInfo.iTotalSockets));

	__ASSERT_DEBUG(aMachineInfo.iTotalSockets<=KMaxMMCardsPerStack,Panic(EWinsMMCBadMachineInfo));

	}

void DWinsMMCStack::AdjustPartialRead(

	const TMMCard* aCard, TUint32 aStart, 

#ifdef _DEBUG

	TUint32 aEnd, 

#else

	TUint32 /*aEnd*/, 

#endif

	TUint32* aPhysStart, TUint32* aPhysEnd) const

	{

	const TUint32 blkLen = 1 << aCard->MaxReadBlLen();

	const TUint32 blkMsk = blkLen - 1;

#ifdef _DEBUG

	__ASSERT_DEBUG(aCard->CSD().ReadBlPartial(), Panic(EWinsMMCAPRNotSupp));

	__ASSERT_DEBUG(aEnd - aStart <= blkLen, Panic(EWinsMMCAPRRange));

	__ASSERT_DEBUG((aEnd & ~blkMsk) > (aStart & ~blkMsk), Panic(EWinsMMCAPRBoundary));

#endif

	*aPhysStart = aStart & ~blkMsk;

	*aPhysEnd = *aPhysStart + blkLen;

	}

void DWinsMMCStack::GetBufferInfo(TUint8** aMDBuf, TInt* aMDBufLen)

	{

	*aMDBuf = iMDBuf;

	*aMDBufLen = iMDBufLen;

	}

void DWinsMMCStack::Panic(TWinsMMCPanic aPanic)

	{

	_LIT(KPncNm,"PBUS-MMC-WINS");

	Kern::PanicCurrentThread(KPncNm,aPanic);

	}

DWinsMMCStack::DWinsMMCStack(TInt aBus, DMMCSocket* aSocket)

	          :DMMCStack(aBus, aSocket)

	{

//	iAddressedCard=0;

//	iSecureArgDevAddr=0;

//	iSecureArgTotalLength=0;

//	iCMD42Failed=EFalse;

	}

/**

    Allocate cards.  Only called at bootup, so no cleanup if fails.

*/

TInt DWinsMMCStack::Init()

	{

    //-- try to read number of mmc cards and slots from epoc.ini file

    const TInt MmcSlots = Property::GetInt("MultiMediaCardSlots");

    const TInt MmcCards = Property::GetInt("MultiMediaCardsNum");

    if(MmcSlots == 0 && MmcCards == 0)

        {//-- parameters not specified, do nothing; static variables are initialized with default values

        }

    else

        {

        if((MmcSlots == 0 && MmcCards >0) || (MmcSlots > 0 && MmcCards ==0))

            {//-- only one of the parameters is specified. use it as "Cards quantity"

            TotalWinsMMC_Cards     = Max(MmcSlots, MmcCards); //-- chose non zero value

            TotalWinsMMC_CardSlots = Max(1, TotalWinsMMC_Cards-1);

            }

        else

            {//-- both parameters are specified

            TotalWinsMMC_Cards     = MmcCards;

            TotalWinsMMC_CardSlots = MmcSlots;

            }

        }//if(!MmcSlots && !MmcCards)

    TotalWinsMMC_Cards      = Min(TotalWinsMMC_Cards, KMax_TotalWinsCards);

    TotalWinsMMC_CardSlots  = Min(TotalWinsMMC_CardSlots, KMax_TotalWinsCardSlots);

    if((iCardArray = new TMMCardArray(this)) == NULL)

		return KErrNoMemory;

	TInt r=DMMCStack::Init();

	if(r!=KErrNone)

		return r;

	DMediaChangeBase* pMCBase = MMCSocket()->iMediaChange;

	static_cast<DWinsMMCMediaChange*>(pMCBase)->SetStackP(this);

	Wins::SetMediaChangeCallBackPtr(DWinsMMCMediaChange::MediaChangeCallBack, (TAny*)pMCBase);

	//

	// Over time memory can become fragmented, and so it is not possible to

	// allocate physically contiguous pages.  Therefore, the buffers for IO

	// are allocated at startup.

	//

	// For the WINS implementation, fragmentation does not matter because

	// DMA is not used.  The memory must still be allocated here so MEDMMC is

	// able to use it.

	//

	// The constant calculations could be folded, but this illustrates how the

	// values are derived.

	//

	// MMC only - values from Hitachi 16Mb card, datasheet HB288016MM1

	// minor buffer must contain enough space for MBR or block

	const TUint mmcBlkSzLog2 = 9;				// READ_BLK_LEN and WRITE_BLK_LEN

	const TUint mmcBlkSz = 1 << mmcBlkSzLog2;

	const TInt mmcMinorBufLen = Max(KDiskSectorSize, mmcBlkSz);

	// There are 2 slots each with up to 2 media drivers; we allocate 8 blocks for each driver.

	// It is the media drivers' responsibility to devide up the buffer space according 

	// to which slot number is allocated to it (DMmcMediaDriverFlash::iCardNumber)

	const TInt KMinMMCBlocksInBuffer = 16 * MMC0_NUMMEDIA;

	const TInt mmcCchBufLen = KMinMMCBlocksInBuffer << mmcBlkSzLog2;

	const TInt mmcTotalBufLen = mmcMinorBufLen + mmcCchBufLen;

	const TInt totalBufLen = mmcTotalBufLen;

	iMDBuf = reinterpret_cast<TUint8*>(Kern::Alloc(totalBufLen));

	iMDBufLen = totalBufLen;

	// setup card size parameters from epoc.ini

	if (TotalMDiskSize==0)

		{

		// Static member variable TotalMDiskSize initialised to zero by default. Set 

		// up static member variables TotalMDiskSize, CSIZE and CSIZE_MULT once and 

		// once only. Use INI file setting if available. Else set to default, IMb.

		TUint cardSize = Property::GetInt("MultiMediaCardSize");

		if (cardSize)

			{

			// set values to match epoc.ini settings

			SetupDiskParms(cardSize);

			}		

		else

			{

			// set default values for 1 MB drive

			TotalMDiskSize=0x100000;

			CSIZE=127;

			CSIZE_MULT=2;

			}

		}

	// Initialise each virtual card that will be used on this stack.

	TInt i;

	for (i=0 ; i<TotalWinsMMC_Cards; i++)

		{

		if ((r=SetupSimulatedCard(i))!=KErrNone)

			return(r);

		}

	// initialize pointers to currently present cards

	// Slot zero can toggle between no card; card 0 and card 1.  The current state is

	// determined by *Kern::CurrentPBusDevicePtr() and toggled by pressing F4 when F5

	// (door open) is held down.  Because this function is only executed at startup,

	// assume start with card zero.

	iCardInfo[0] = iCardPool[0];

	for (i = 1; i < TotalWinsMMC_CardSlots; ++i)

		{

		iCardInfo[i]=iCardPool[i+1];

		}

	return(KErrNone);

	}

TInt DWinsMMCStack::CreateBinFileForCard(TInt aCardNum,HANDLE* aHandle,TBool aCreateNew)

//

// create .bin file in temp directory to contain media area of card.

//

	{

	const char* emulatorPath = Property::GetString("EmulatorMediaPath");

	if (!Emulator::CreateAllDirectories(emulatorPath))

		return Emulator::LastError();

	TBuf8<KMaxFileName> fn8(_L8(emulatorPath));

	fn8.Append(_L8("MMCCRD"));

	fn8.AppendNum(aCardNum);

	fn8.Append(_L8("A.BIN"));

	fn8.Append('\0');

	*aHandle = CreateFileA(

		(LPCSTR) fn8.Ptr(),							// LPCSTR lpFileName,

		GENERIC_READ | GENERIC_WRITE,				// DWORD dwDesiredAccess

		FILE_SHARE_READ | FILE_SHARE_WRITE,			// DWORD dwShareMode

		NULL,										// LPSECURITY_ATTRIBUTES lpSecurityAttributes

		aCreateNew ? CREATE_ALWAYS : OPEN_ALWAYS,	// DWORD dwCreationDisposition

		FILE_FLAG_RANDOM_ACCESS,					// DWORD dwFlagsAndAttributes

			NULL);									// HANDLE hTemplateFile

	TInt fileSize=GetFileSize(*aHandle,NULL);

	if (fileSize>TotalMDiskSize)

		//

		// The Drive file already exists and size of emulated drive as configured in 

		// epoc.ini has been reduced. Musn't corrupt the emulated drive so delete the 

		// drive file and start from scratch. The emulated drive contents will be 

		// erased.

		//

		{

		CloseHandle(*aHandle);

		DeleteFileA(

			(LPCSTR) fn8.Ptr());						// LPCSTR lpFileName,			

		*aHandle = CreateFileA(

			(LPCSTR) fn8.Ptr(),							// LPCSTR lpFileName,

			GENERIC_READ | GENERIC_WRITE,				// DWORD dwDesiredAccess

			FILE_SHARE_READ | FILE_SHARE_WRITE,			// DWORD dwShareMode

			NULL,										// LPSECURITY_ATTRIBUTES lpSecurityAttributes

			aCreateNew ? CREATE_ALWAYS : OPEN_ALWAYS,	// DWORD dwCreationDisposition

			FILE_FLAG_RANDOM_ACCESS,					// DWORD dwFlagsAndAttributes

				NULL);									// HANDLE hTemplateFile

		}

	if (*aHandle==INVALID_HANDLE_VALUE)

		return(MapLastErrorEpoc());

	if (SetFilePointer(*aHandle,TotalMDiskSize,NULL,FILE_BEGIN)==0xffffffffu

		||	! SetEndOfFile(*aHandle) )

		{

		CloseHandle(*aHandle);

	    return(MapLastErrorEpoc());

		}

	return KErrNone;

	}

TInt DWinsMMCStack::SetupSimulatedCard(TInt aCardNum)

//

// allocate individual card with Win32 file.  Only called at bootup, so no cleanup if fails.

//

	{

	TWinsCardInfo* cip = new TWinsCardInfo;

	if (cip == 0)

		return(KErrNoMemory);

	TUint8 cid[KMMCCIDLength];

	cid[0] = 'C';

	cid[1] = 'I';

	cid[2] = 'D';

	cid[3] = TUint8('0' + aCardNum);

	TInt j;

	for (j = 4; j < KMMCCIDLength - 1; ++j)

		cid[j] = 'c';

	cid[KMMCCIDLength - 1] = '#';				// '#' = 0x23, bit zero must be 1

	cip->iCID=cid;

	cip->iPWD=new TMediaPassword;

	if (!cip->iPWD)

		{

		delete cip;

		return(KErrNoMemory);

		}

	cip->iState=ECardStateIdle;

	HANDLE h=NULL;

	TInt err;

	if ( (err=CreateBinFileForCard(aCardNum,&h))!=KErrNone )

		{

		delete cip;

		return(err);

		}

	cip->iWinHandle=h;

	iCardPool[aCardNum]=cip;

	return(KErrNone);

	}

void DWinsMMCStack::SetBusConfigDefaults(TMMCBusConfig& aConfig, TUint aClock)

//

// Fills BusConfig structure with default values

//

	{

	const TUint KWinsMaxHwInterfaceClk=104000;

	const TUint KWinsResponseTimeOut=6400;

	const TUint KWinsDataTimeOut=40000;

	const TUint KWinsBusyTimeOut=200000;

	aConfig.iBusClock = (aClock > KWinsMaxHwInterfaceClk) ? KWinsMaxHwInterfaceClk : aClock;

	aConfig.iResponseTimeOut=KWinsResponseTimeOut;

	aConfig.iDataTimeOut=KWinsDataTimeOut;

	aConfig.iBusyTimeOut=KWinsBusyTimeOut;

	}

void DWinsMMCStack::InitClockOff()

//

// Switch of the identification mode clock and enable the data transfer mode

// clock instead.

//

	{

	// empty.

	}

void DWinsMMCStack::ASSPReset()

//

// Stop all activities on the host stack

//

	{

	// empty.

	}

void DWinsMMCStack::ASSPDisengage()

//

// Forced release of all ASSP resources

//

	{

	}

void DWinsMMCStack::DoPowerDown()

//

// Power down the bus

//

	{

	// Change the state of all virtual cards present to Idle

	for (TInt i=0 ; i<TotalWinsMMC_CardSlots ; i++)

		iCardInfo[i]->iState=ECardStateIdle;

	}

LOCAL_C TInt SetMediaPasswordEnvironmentVar(TInt aSocketNum,TInt aCardNum,const TDesC8& aPasswd)

// 

// Set the password for local drive 'aLocalDrive', card number 'aCardNum' to 'aPasswd' - as an

// environment variable. Note that the card number is only relevant where the emulated drive

// supports card hot-swapping (i.e. F4 whilst F5 is held down).

//

	{

	// Setup the appropriate environment variable string '_EPOC_LocDrv_<locDrvNum>_PWORD_<cardNum>'

	TUint16 envVar[]=L"_EPOC_Socket_X_PWORD_Y";

	envVar[13]=(TUint16)('0'+aSocketNum);

	envVar[21]=(TUint16)('0'+aCardNum);

	// Setup the new value of the environment variable

	TUint16	envVal[100];

	TInt len=aPasswd.Length();

	// the password may be empty if a card's password is cleared

	if (len>(100-1))

		return(KErrArgument);

	memcpy(&envVal[0],reinterpret_cast<const TUint16 *>(aPasswd.Ptr()),len);

	envVal[len>>1]='\0';

	// Now set the new value for the environment variable

	if (SetEnvironmentVariable(envVar,&envVal[0]))

		return(KErrNone);

	return KErrGeneral;

	}

LOCAL_C TInt MediaPasswordEnvironmentVar(TInt aSocketNum,TInt aCardNum,TDes8& aPasswd)

// 

// Get the password for local drive 'aLocalDrive', card number 'aCardNum' into 'aPasswd' - from

// an environment variable. Note that the card number is only relevant where the emulated drive

// supports card hot-swapping (i.e. F4 whilst F5 is held down).

//

	{

	TUint16 envVar[]=L"_EPOC_Socket_X_PWORD_Y";

	envVar[13]=(TUint16)('0'+aSocketNum);

	envVar[21]=(TUint16)('0'+aCardNum);

	TUint16 envVal[100];	// To hold the value of the retreived environment variable

	DWORD len=GetEnvironmentVariable(envVar,&envVal[0],100);

	if (len>(TUint)100)

		return(KErrGeneral);

	if (len)

		{

		// Found the requested environment variable so there is a password for this local drive / card. 

		if ((len<<1)<=KMaxMediaPassword)

			{

			aPasswd.FillZ(KMaxMediaPassword);

			aPasswd.Zero();

			aPasswd.Copy(reinterpret_cast<TUint8*>(&envVal[0]),len<<1);

			return(KErrNone);	

			}

		else	

			return(KErrGeneral);	

		}

	return(KErrNotFound);

	}

TMMCErr DWinsMMCStack::DoPowerUpSM()

//

//	State Machine functions implemented in ASSP layer

//

	{

	enum states

		{

		EStBegin=0,

		EStEnd

		};

	SMF_BEGIN

	__KTRACE_OPT(KPBUS1, Kern::Printf("DoPowerUpSM: BEGIN"));

	if( MMCSocket()->iVcc->SetState(EPsuOnCurLimit) != KErrNone )

		return( KMMCErrHardware );

	for (TInt i=0 ; i<TotalWinsMMC_CardSlots ; i++)

		{

		// Attempt to retrieve a password for this card from environment settings (as long as this

		// isn't card0 and we are simulating this is not present)

		TInt cardNum=(i==0) ? *Wins::CurrentPBusDevicePtr() : i;

		if (cardNum>=0 && MediaPasswordEnvironmentVar(MMCSocket()->iSocketNumber,cardNum,*(iCardInfo[i]->iPWD))==KErrNone)

			{

			// Card has a password so lock it automatically on power up.		

			iCardInfo[i]->iIsLocked=(iCardInfo[i]->iPWD->Length() > 0);