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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// This LDD provides a set of direct interface functions with the kernel 

// MultiMediaCard Controller

// 

//

#include <kernel/kernel.h>

#include <drivers/mmc.h>

#include "d_mmctest.h"

const TInt KMajorVersionNumber=1;

const TInt KMinorVersionNumber=0;

const TInt KBuildVersionNumber=0;

const TInt KStackNumber  = 0;

const TInt KMaxMMCCardsPerStack = 4;

// global Dfc Que

TDynamicDfcQue* gDfcQ;

class DLddFactoryMmcCntrlInterface : public DLogicalDevice

	{

public:

	DLddFactoryMmcCntrlInterface();

	virtual ~DLddFactoryMmcCntrlInterface();

	virtual TInt Install();

	virtual void GetCaps(TDes8 &aDes) const;

	virtual TInt Create(DLogicalChannelBase*& aChannel); 	//overriding pure virtual

	};

class DLddMmcCntrlInterface : public DLogicalChannel

	{

public:

	DLddMmcCntrlInterface();

	~DLddMmcCntrlInterface();

protected:

	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

	virtual void HandleMsg(class TMessageBase *);

private:

	void DoCancel(TInt aReqNo);

	TInt DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2);

	TInt DoControl(TInt aFunction, TAny* a1, TAny* a2);

	TInt PrintCardInfo();	

private:

    void Reset();

    static void SessionEndCallBack(TAny *aPtr);

    static void SessionEndDfc(TAny *aPtr);

	static void EventCallBack(TAny* aPtr, TInt aReason, TAny* a1, TAny* a2);

private:

    enum TPanic {EReadDes,EWriteDes,EWriteTInt,EUnknownMmcSes};

    enum TMmcSessionCmd {EMmcSesNone,EMmcSesReadBlk,EMmcSesWriteBlk, EMmcSesReadExtCSD};

    TInt iStackNum;

	DMMCSocket* iSocketP;

    DMMCStack* iStack;

    TMMCard* iCard;

    DMMCSession* iSession;

    TMmcSessionCmd iMmcSessionCmd;

    TAny* iClientDesPtr;

	TUint32 iBlkOffet;

	TRequestStatus* iReadWriteStatusP;

    TMMCCallBack iSessionEndCallBack;

	TDfc iSessionEndDfc;

	TPBusCallBack iBusEventCallback;

	TRequestStatus* iPowerUpStatusP;

//	TUint8 iBuf[KDrvBufSizeInBytes];	// iBuf now uses the MMC DMA buffer, until DT issue with H4 is resolved

	TUint8* iBuf;

	DThread* iClient;

	TExtendedCSD iExtendedCSD;

    };

DECLARE_STANDARD_LDD()

	{

	return new DLddFactoryMmcCntrlInterface;

	}

DLddFactoryMmcCntrlInterface::DLddFactoryMmcCntrlInterface()

//

// Constructor

//

	{

    iParseMask=KDeviceAllowUnit;  // Pass stack number as unit

	iUnitsMask=0xffffffff;

	iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

	}

TInt DLddFactoryMmcCntrlInterface::Create(DLogicalChannelBase*& aChannel)

//

// Create a new DLddFactoryMmcCntrlInterface on this logical device

//

	{

	aChannel=new DLddMmcCntrlInterface;

	return aChannel ? KErrNone : KErrNoMemory;

	}

const TInt KDMmcThreadPriority = 27;

_LIT(KDMmcThread,"DMmcTestThread");

TInt DLddFactoryMmcCntrlInterface::Install()

//

// Install the device driver.

//

	{

	// Allocate a kernel thread to run the DFC 

	TInt r = Kern::DynamicDfcQCreate(gDfcQ, KDMmcThreadPriority, KDMmcThread);

	if (r != KErrNone)

		return r; 	

    TPtrC name=_L("MmcTest");

	return(SetName(&name));

	}

void DLddFactoryMmcCntrlInterface::GetCaps(TDes8 &aDes) const

//

// Return the Pc Card Contoller Interface ldd's capabilities.

//

	{

    TCapsMmcIfV01 b;

	b.version=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

    Kern::InfoCopy(aDes,(TUint8*)&b,sizeof(b));

	}

/**

  Destructor

*/

DLddFactoryMmcCntrlInterface::~DLddFactoryMmcCntrlInterface()

	{

	if (gDfcQ)

		gDfcQ->Destroy();

	}

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

DLddMmcCntrlInterface::DLddMmcCntrlInterface()

//

// Constructor

//

	: iSessionEndCallBack(DLddMmcCntrlInterface::SessionEndCallBack,this),

	  iSessionEndDfc(DLddMmcCntrlInterface::SessionEndDfc, this, 1),

	  iBusEventCallback(DLddMmcCntrlInterface::EventCallBack, this)

	{

//	iMmcController=NULL;

//  iStackNum=0;

//  iStack=NULL;

//  iCard=NULL;

//  iSession=NULL;

//  iMmcSessionCmd=EMmcSesNone;

//  iClientDesPtr=NULL;

//	iBlkOffet=0;

	iClient=&Kern::CurrentThread();

	((DObject*)iClient)->Open();	// can't fail since thread is running

    }

#pragma warning( default : 4355 )

DLddMmcCntrlInterface::~DLddMmcCntrlInterface()

//

// Destructor

//

	{

    Reset();

	iBusEventCallback.Remove();

	delete iSession;

	Kern::SafeClose((DObject*&)iClient,NULL);

    }

TInt DLddMmcCntrlInterface::DoCreate(TInt aUnit, const TDesC8* /*aInfo*/, const TVersion& aVer)

//

// Create channel.

//

	{    

	if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber),aVer))

		return(KErrNotSupported);

	//

	// Obtain the appropriate card from the socket/stack

	//

	iSocketP = static_cast<DMMCSocket*>(DPBusSocket::SocketFromId(aUnit));

	if(iSocketP == NULL)

		return(KErrNoMemory);

	iStack = static_cast<DMMCStack*>(iSocketP->Stack(KStackNumber));

	if(iStack == NULL)

		return(KErrNoMemory);

    // Create an MMC session object

	iSession = iStack->AllocSession(iSessionEndCallBack);

    if (iSession==NULL)

		return(KErrNoMemory);

    iSession->SetStack(iStack);

	TUint8* buf;

	TInt bufLen;

	TInt minorBufLen;

	iStack->BufferInfo(buf, bufLen, minorBufLen);

	iBuf = buf;

	SetDfcQ(gDfcQ);

	iMsgQ.Receive();

	iSessionEndDfc.SetDfcQ(gDfcQ);

	iBusEventCallback.SetSocket(aUnit);

	iBusEventCallback.Add();

    return(KErrNone);

	}

void DLddMmcCntrlInterface::DoCancel(TInt /*aReqNo*/)

//

// Cancel an outstanding request.

//

	{

	}

void DLddMmcCntrlInterface::HandleMsg(TMessageBase* aMsg)

    {

    TThreadMessage& m=*(TThreadMessage*)aMsg;

    TInt id=m.iValue;

	if (id==(TInt)ECloseMsg)

		{

		m.Complete(KErrNone, EFalse);

		return;

		}

    else if (id==KMaxTInt)

		{

		// DoCancel

		m.Complete(KErrNone,ETrue);

		return;

		}

    if (id<0)

		{

		// DoRequest

		TRequestStatus* pS=(TRequestStatus*)m.Ptr0();

		TInt r=DoRequest(~id, pS, m.Ptr1(), m.Ptr2());

		if (r!=KErrNone)

	    	Kern::RequestComplete(iClient, pS, r);

		m.Complete(KErrNone,ETrue);

		}

    else

		{

		// DoControl

		TInt r=DoControl(id,m.Ptr0(),m.Ptr1());

		if(r != KErrCompletion)

			{

			m.Complete(r,ETrue);

			}

		}

	}

TInt DLddMmcCntrlInterface::PrintCardInfo()

    {

    if(iCard == NULL)

        {

        return(KErrNotReady);

        }

    const TCSD& csd = iCard->CSD();

    Kern::Printf("CSD");    

    Kern::Printf("CSDStructure():                 %u",csd.CSDStructure());

    Kern::Printf("SpecVers():                     %u",csd.SpecVers());

    switch (csd.MediaType())

        {

        case EMultiMediaROM   : Kern::Printf("Read Only Media"); break;

        case EMultiMediaFlash : Kern::Printf("Writable Media"); break;

        case EMultiMediaIO    : Kern::Printf("IO Media Device"); break;

        case EMultiMediaOther : Kern::Printf("UNKNOWN Media type"); break;

        default : Kern::Printf("Media NOT SUPPORTED");

        }    

    Kern::Printf("----------------------------------");

    Kern::Printf("Reserved120():                  %u",csd.Reserved120());

    Kern::Printf("TAAC():                         %u", csd.TAAC());

    Kern::Printf("NSAC():                         %u", csd.NSAC());

    Kern::Printf("TranSpeed():                    %u", csd.TranSpeed());

    Kern::Printf("CCC():                          %u",csd.CCC());

    Kern::Printf("ReadBlLen():                    %u", csd.ReadBlLen());

    Kern::Printf("ReadBlPartial():                %u", (TUint)csd.ReadBlPartial());

    Kern::Printf("WriteBlkMisalign():             %u", (TUint) csd.WriteBlkMisalign());

    Kern::Printf("ReadBlkMisalign():              %u", (TUint) csd.ReadBlkMisalign());

    Kern::Printf("DSRImp():                       %u", (TUint) csd.DSRImp());

    Kern::Printf("Reserved74():                   %u", csd.Reserved74());

    Kern::Printf("CSize():                        %u", csd.CSize());

    Kern::Printf("VDDRCurrMin():                  %u", csd.VDDRCurrMin());

    Kern::Printf("VDDRCurrMax():                  %u", csd.VDDRCurrMax());

    Kern::Printf("VDDWCurrMin():                  %u", csd.VDDWCurrMin());

    Kern::Printf("VDDWCurrMax():                  %u", csd.VDDWCurrMax());

    Kern::Printf("CSizeMult():                    %u", csd.CSizeMult());

    Kern::Printf("EraseGrpSize():                 %u", csd.EraseGrpSize());

    Kern::Printf("EraseGrpMult():                 %u", csd.EraseGrpMult());

    Kern::Printf("WPGrpSize():                    %u", csd.WPGrpSize());

    Kern::Printf("WPGrpEnable():                  %u", csd.WPGrpEnable());            

    Kern::Printf("DefaultECC():                   %u", csd.DefaultECC());

    Kern::Printf("R2WFactor():                    %u", csd.R2WFactor());

    Kern::Printf("WriteBlLen():                   %u", csd.WriteBlLen());

    Kern::Printf("WriteBlPartial():               %u", (TUint) csd.WriteBlPartial());

    Kern::Printf("Reserved16():                   %u", csd.Reserved16());

    Kern::Printf("FileFormatGrp():                %u", (TUint) csd.FileFormatGrp());

    Kern::Printf("Copy():                         %u", (TUint) csd.Copy());

    Kern::Printf("PermWriteProtect():             %u", (TUint) csd.PermWriteProtect());

    Kern::Printf("TmpWriteProtect():              %u", (TUint) csd.TmpWriteProtect());

    Kern::Printf("FileFormat():                   %u", csd.FileFormat());

    Kern::Printf("ECC():                          %u", csd.ECC());

    Kern::Printf("CRC():                          %u", csd.CRC());

    Kern::Printf("DeviceSize():                   %u", csd.DeviceSize());   

    Kern::Printf("ReadBlockLength():              %u", csd.ReadBlockLength());

    Kern::Printf("WriteBlockLength():             %u", csd.WriteBlockLength());

    Kern::Printf("EraseSectorSize():              %u", csd.EraseSectorSize());

    Kern::Printf("EraseGroupSize():               %u", csd.EraseGroupSize());

    Kern::Printf("MinReadCurrentInMilliamps():    %u", csd.MinReadCurrentInMilliamps());

    Kern::Printf("MinWriteCurrentInMilliamps():   %u", csd.MinWriteCurrentInMilliamps());

    Kern::Printf("MaxReadCurrentInMilliamps():    %u", csd.MaxReadCurrentInMilliamps());

    Kern::Printf("MaxWriteCurrentInMilliamps():   %u", csd.MaxWriteCurrentInMilliamps());

    Kern::Printf("MaxTranSpeedInKilohertz():      %u", csd.MaxTranSpeedInKilohertz());

    const TExtendedCSD& extcsd = iCard->iExtendedCSD;

    Kern::Printf("\nExtended CSD");

    Kern::Printf("CSDStructureVer:                %u", extcsd.CSDStructureVer());

    Kern::Printf("ExtendedCSDRev:                 %u", extcsd.ExtendedCSDRev());

    Kern::Printf("----------------------------------");

    Kern::Printf("SupportedCmdSet:                %u", extcsd.SupportedCmdSet());

    Kern::Printf("SectorCount:                    %u", extcsd.SectorCount());

    Kern::Printf("MinPerfWrite8Bit52Mhz:          %u", extcsd.MinPerfWrite8Bit52Mhz());

    Kern::Printf("MinPerfRead8Bit52Mhz:           %u", extcsd.MinPerfRead8Bit52Mhz());

    Kern::Printf("MinPerfRead8Bit26Mhz_4Bit52Mhz: %u", extcsd.MinPerfRead8Bit26Mhz_4Bit52Mhz());

    Kern::Printf("MinPerfWrite4Bit26Mhz:          %u", extcsd.MinPerfWrite4Bit26Mhz());

    Kern::Printf("MinPerfRead4Bit26Mhz:           %u", extcsd.MinPerfRead4Bit26Mhz());

    Kern::Printf("PowerClass26Mhz360V:            0x%02X", extcsd.PowerClass26Mhz360V());

    Kern::Printf("PowerClass52Mhz360V:            0x%02X", extcsd.PowerClass52Mhz360V());

    Kern::Printf("PowerClass26Mhz195V:            0x%02X", extcsd.PowerClass26Mhz195V());

    Kern::Printf("PowerClass52Mhz195V:            0x%02X", extcsd.PowerClass52Mhz195V());

    Kern::Printf("CardType:                       %u", extcsd.CardType());

    Kern::Printf("CmdSet:                         %u", extcsd.CmdSet());

    Kern::Printf("CmdSetRev:                      %u", extcsd.CmdSetRev());

    Kern::Printf("PowerClass:                     %u", extcsd.PowerClass());

    Kern::Printf("HighSpeedTiming:                %u", extcsd.HighSpeedTiming());

    Kern::Printf("BusWidthMode:                   %u", extcsd.BusWidthMode());

    Kern::Printf("HighCapacityEraseGroupSize:     %u", extcsd.HighCapacityEraseGroupSize());

    Kern::Printf("AccessSize:                     %u", extcsd.AccessSize());

    Kern::Printf("BootInfo:                       %u", extcsd.BootInfo() );

    Kern::Printf("BootSizeMultiple:               %u", extcsd.BootSizeMultiple() );

    Kern::Printf("EraseTimeoutMultiple:           %u", extcsd.EraseTimeoutMultiple() );

    Kern::Printf("ReliableWriteSector:            %u", extcsd.ReliableWriteSector() );

    Kern::Printf("HighCapWriteProtGroupSize:      %u", extcsd.HighCapacityWriteProtectGroupSize() );

    Kern::Printf("SleepCurrentVcc:                %u", extcsd.SleepCurrentVcc() );

    Kern::Printf("SleepCurrentVccQ:               %u", extcsd.SleepCurrentVccQ());

    Kern::Printf("SleepAwakeTimeout:              %u", extcsd.SleepAwakeTimeout());

    Kern::Printf("BootConfig:                     %u", extcsd.BootConfig());

    Kern::Printf("BootBusWidth:                   %u", extcsd.BootBusWidth());

    Kern::Printf("EraseGroupDef:                  %u", extcsd.EraseGroupDef());

    return KErrNone;

    }

TInt DLddMmcCntrlInterface::DoRequest(TInt aFunction, TRequestStatus* aStatus, TAny* a1, TAny* a2)

//

// Most Async requests

//

	{

    if (iMmcSessionCmd!=EMmcSesNone)

		{

		return(KErrInUse);

		}

    switch (aFunction)

		{

        case RMmcCntrlIf::EReqPwrUp:

			{

			if(!iSocketP->CardIsPresent())

				{

				Kern::RequestComplete(iClient, aStatus, KErrNotReady);

				}

			else if(iSocketP->State() == EPBusOn)

				{

				Kern::RequestComplete(iClient, aStatus, KErrNone);

				}

			else

				{

				iPowerUpStatusP = aStatus;

				iSocketP->PowerUp();

				}

			break;

			}

        case RMmcCntrlIf::EReqReadSect:

            {

			if(iCard == NULL)

				{

				return(KErrNotReady);

				}

			//TCSD csd=iCard->CSD();

			iReadWriteStatusP = aStatus;

			TUint32 srcAddr=((TUint32)a1)<<KSectorSizeShift;

			TUint readBlLen = 1 << iCard->MaxReadBlLen();

			TUint readBlMask=(readBlLen-1);

			iBlkOffet=srcAddr-(srcAddr&(~readBlMask));

			iClientDesPtr=a2;

			iMmcSessionCmd=EMmcSesReadBlk;

			srcAddr&=(~readBlMask);

			TMMCArgument da(srcAddr);

			iSession->SetupCIMReadBlock(da,readBlLen,&iBuf[0]);

			iSession->Engage();

			break;

            }

        case RMmcCntrlIf::EReqWriteSect:

            {

			if(iCard == NULL)

				{

				return(KErrNotReady);

				}

			iReadWriteStatusP = aStatus;

			TUint32 destAddr=((TUint32)a1)<<KSectorSizeShift;

			TUint writeBlLen=1 << iCard->MaxWriteBlLen();

			TUint writeBlMask=(writeBlLen-1);

			iBlkOffet=destAddr-(destAddr&(~writeBlMask));

			TPtr8* srcDes = (TPtr8*)a2;		

			TPtr8 ptr(&iBuf[iBlkOffet],KSectorSizeInBytes,KSectorSizeInBytes);

			TInt r = Kern::ThreadDesRead(iClient, srcDes, ptr, 0, KChunkShiftBy0);

			if(r != KErrNone)

				{

				return(r);

				}

			iMmcSessionCmd=EMmcSesWriteBlk;

			destAddr&=(~writeBlMask);

			iSession->SetupCIMWriteBlock(TMMCArgument(destAddr),writeBlLen,&iBuf[0]);

			iSession->Engage();

			break;

			}

        case RMmcCntrlIf::EReqReadExtCSD:

            {

			if(iCard == NULL)

				{

				return(KErrNotReady);

				}

			iClientDesPtr = a1;

			iReadWriteStatusP = aStatus;

			iMmcSessionCmd = EMmcSesReadExtCSD;

			iSession->SetupDTCommand(

				ECmdSendExtendedCSD, 

				TMMCArgument(0),

				KMMCExtendedCSDLength,

				(TUint8*) &iExtendedCSD);

			iSession->Engage();

			break;

            }

        case RMmcCntrlIf::EReqMMCInfoPrint:

            {

            // Print CSD & Extended CSD values

            TInt r = PrintCardInfo();            

            Kern::RequestComplete(iClient, aStatus, r);

            break;

            }

        }

	return(KErrNone);

	}

TInt DLddMmcCntrlInterface::DoControl(TInt aFunction,TAny* a1,TAny* /*a2*/)

//

// Mostly requests (but some kernel server async ones)

//

	{

	TInt r=KErrNotSupported;

	switch (aFunction)

		{

        case RMmcCntrlIf::ESvReset:

            {

            Reset();

			r=KErrNone;

			break;

            }

        case RMmcCntrlIf::ESvPwrDown:

			{

//		    iStack->PowerDown(); ???

//          iMmcController->SetPowerEvent(0,EPEventPwrDownNormal,0);

			r=KErrNone;

			break;

			}

        case RMmcCntrlIf::EExecStackInfo:

            {

            // Determine the number of cards present

            TUint cardsPresentMask=0x00000000;

	        TMMCard* card;

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

                {

                card=iStack->CardP(i);

                if (card!=NULL && card->IsPresent())

                    cardsPresentMask|=(0x1<<i);

                }

			r = Kern::ThreadRawWrite(iClient,a1,&cardsPresentMask,sizeof(TUint));

			break;

            }

        case RMmcCntrlIf::ESvRegisterEvent:

            {

			return(KErrNotSupported);

            }

        case RMmcCntrlIf::EExecSelectCard:

            {

            iCard=iStack->CardP((TUint)a1);

            iSession->SetCard(iCard);

			r=KErrNone;

			break;