// Copyright (c) 1998-2009 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:

// e32\drivers\pbus\pccard\socket.cpp

// 

//

#include <pccard.h>

#include "cis.h"

const TInt KFuncGranularity=(KMaxFuncPerCard+1);

const TInt KMemGranularity=2;

TPccdFuncType FuncType(TUint aFuncCode)

	{

	if (aFuncCode<=KCisTplFuncIdScsi)

		return((TPccdFuncType)(aFuncCode+1));

	else if (aFuncCode==KCisTplFuncIdVendorSpecific)

		return(EVendorSpecificCard);

	else

		return(EUnknownCard);

	}

/********************************************

 * PC card power supply

 ********************************************/

DPcCardVcc::DPcCardVcc(TInt aPsuNum, TInt aMediaChangeNum)

	:	DPBusPsuBase(aPsuNum, aMediaChangeNum)

	{

	}

TInt DPcCardVcc::SocketVccToMilliVolts(TPccdSocketVcc aVcc)

//

// Converts a TPccdSocketVcc into a integer value - units mV.

//

	{

	switch (aVcc)

		{

		case EPccdSocket_5V0: return(5000);

		case EPccdSocket_3V3: return(3300);

		default: return(0);

		}

	}

TBool DPcCardVcc::IsLocked()

	{

/*	TInt i;

	Kern::EnterCS();

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

		{

		DPcCardSocket* pS=(DPcCardSocket*)TheSockets[i];

		if (pS && pS->iVcc==this)

			{

			if (pS->iClientWindows || pS->iActiveConfigs)

				break;

			}

		}

	Kern::LeaveCS();

	return (i<KMaxPccdSockets);

*/

	DPcCardSocket* pS=(DPcCardSocket*)iSocket;

	return (pS->iClientWindows || pS->iActiveConfigs);

	}

void DPcCardVcc::ReceiveVoltageCheckResult(TInt anError)

	{

	__KTRACE_OPT(KPBUS1,Kern::Printf("DPcCardVcc(%d)::ReceiveVoltageCheckResult(%d)",iPsuNum,anError));

	DPcCardSocket* pS=(DPcCardSocket*)iSocket;

	TInt s=pS->iCardPowerUpState;

	if (s==DPcCardSocket::EWaitForVccReading)

		{

		if (anError==KErrNone)

			{

			SetState(EPsuOnFull);

			pS->iCardPowerUpState=DPcCardSocket::EWaitForReady;

			}

		else

			pS->TerminatePowerUpSequence(KErrCorrupt);

		}

	else if (s!=DPcCardSocket::EInit && s!=DPcCardSocket::EApplyingReset && s!=DPcCardSocket::ECheckVcc)

		DPBusPsuBase::ReceiveVoltageCheckResult(anError);

	}

/********************************************

 * PC card media change

 ********************************************/

DPcCardMediaChange::DPcCardMediaChange(TInt aMediaChangeNum)

	: DMediaChangeBase(aMediaChangeNum)

	{

	}

TInt DPcCardMediaChange::Create()

	{

	return DMediaChangeBase::Create();

	}

/********************************************

 * PC card socket

 ********************************************/

void cardPowerUpTick(TAny* aPtr)

	{

	((DPcCardSocket*)aPtr)->iCardPowerUpDfc.Enque();

	}

void cardPowerUpDfc(TAny* aPtr)

	{

	((DPcCardSocket*)aPtr)->CardPowerUpTick();

	}

DPcCardSocket::DPcCardSocket(TSocket aSocketNum)

//

// Constructor.

//

	:	DPBusSocket(aSocketNum),

		iCardFuncArray(KFuncGranularity),

		iMemChunks(KMemGranularity),

		iCardPowerUpDfc(cardPowerUpDfc, this, 1)

	{

	iType=EPBusTypePcCard;

//	iCardPowerUpState=EIdle;

//	iClientWindows=0;

//	iActiveConfigs=0;

	}

TInt DPcCardSocket::Create(const TDesC* aName)

//

// Create a new Socket. Only created once on kernel initialization so don't

// worry about cleanup if it fails.

//

	{

	__KTRACE_OPT(KPBUS1,Kern::Printf(">Skt(%d):Create(%lS)",iSocketNumber,aName));

	TInt r=DPBusSocket::Create(aName);

	if (r!=KErrNone)

		return r;

	iCardPowerUpDfc.SetDfcQ(&iDfcQ);

	// Create card function array - add and remove a dummy function to pre-allocate array memory.

	// This way, adding new functions to array never causes any memory allocation.

	r=AddNewFunc(0,EPccdAttribMem);				// Add dummy function

	if (r!=KErrNone)

		return r;

	delete iCardFuncArray[0];					// Destroy dummy function

	iCardFuncArray.Remove(0);					// Remove pointer to dummy from array

	// Now allocate the permanent attribute memory chunk. Don't bother about what

	// access speed we asign, it gets set each time we subsequently access the chunk.

	TPccdChnk chnk(EPccdAttribMem,0,KDefaultAttribMemSize);

	r=iAttribWin.Create(this,chnk,EAcSpeed300nS,KPccdChunkPermanent|KPccdChunkShared|KPccdChunkSystemOwned);

	return r;

	}

void DPcCardSocket::ResetPowerUpState()

	{

	__KTRACE_OPT(KPBUS1,Kern::Printf(">Skt(%d):ResetPowerUpState",iSocketNumber));

	if (iCardPowerUpState!=EIdle)

		{

		iCardPowerUpTimer.Cancel();

		iCardPowerUpDfc.Cancel();

		iCardPowerUpState=EIdle;

		}

	}

void DPcCardSocket::Reset1()

	{

	__KTRACE_OPT(KPBUS1,Kern::Printf(">Skt(%d):Reset1",iSocketNumber));

	ResetPowerUpState();

	}

void DPcCardSocket::Reset2()

//

// Reset the socket (called to remove any allocated memory following a

// media change event).

//

	{

	__KTRACE_OPT(KPBUS1,Kern::Printf(">Skt(%d):Rst2",iSocketNumber));

	// Destroy all the function objects

	TInt i;

	for (i=CardFuncCount()-1;i>=0;i--)

		{

		delete iCardFuncArray[i];

		iCardFuncArray.Remove(i);		// Now remove from array (doesn't cause memory dealloc).

		}

	iActiveConfigs=0;

	// Destroy all the non-permanent Pc Card chunks

	for (i=(iMemChunks.Count()-1);i>=0;i--)

		{

		if ( iMemChunks[i]->IsRemovable() )

			iMemChunks[i]->Close();

		}

	iMemChunks.Compress();

	}

void DPcCardSocket::Restore()

//

// Restore the socket. Normally called when restoring a socket after it has been powered 

// down due to inactivity (but not media change)

//

	{	

	TInt i;

	TPcCardFunction *cf;

	for (i=CardFuncCount()-1;i>=0;i--)

		{

		cf=iCardFuncArray[i];

		TUint8 index;

		if ((index=(TUint8)cf->ConfigOption())!=KInvalidConfOpt && cf->IsRestorableConfig())

			WriteConfigReg(i,KConfigOptionReg,index);

		}

	}

void DPcCardSocket::RemoveChunk(DPccdChunkBase *aChunk)

//

// Remove a chunk from this socket. 

//	

	{

	TInt i;

	for (i=0;i<iMemChunks.Count();i++)

		{

		if (iMemChunks[i]==aChunk)

			{

			iMemChunks.Remove(i);

			iMemChunks.Compress();

			return;

			}

		}

	}

EXPORT_C TInt DPcCardSocket::RequestConfig(TInt aCardFunc,DBase *aClientID,TPcCardConfig &anInfo,TUint aFlag)

//

// Configure the card.

//

	{

	__KTRACE_OPT(KPBUS1,Kern::Printf(">Skt(%d):RequestConfig(F:%d O:%xH B:%xH L:%xH)",iSocketNumber,aCardFunc,\

										   anInfo.iConfigOption,anInfo.iConfigBaseAddr,anInfo.iRegPresent));

	if (!IsValidCardFunc(aCardFunc))

		return(KErrArgument);

	// Check that this function isn't configured already

	TPcCardFunction *cf=iCardFuncArray[aCardFunc];

	if (cf->IsConfigured())

		return(KErrInUse);	   // Its already configured.

	// If configuration registers are within attribute chunk then configure the

	// card (rather than use the registers present info, assume all registers are

	// present - ie size of mask).

	if (anInfo.iConfigBaseAddr+(sizeof(anInfo.iRegPresent)<<1)>KDefaultAttribMemSize)

		return(KErrNotSupported);

	anInfo.iConfigOption&=(KConfOptLevIReqM|KConfOptConfM); // Mustn't allow msb - KInvalidConfOpt

	TPccdAccessSpeed sp=(VccSetting()==EPccdSocket_3V3)?EAcSpeed600nS:EAcSpeed300nS;

	iAttribWin.SetAccessSpeed(sp);

	iAttribWin.SetupChunkHw();

	iAttribWin.Write(anInfo.iConfigBaseAddr,(TUint8*)&anInfo.iConfigOption,1);

	cf->SetConfigRegMask(anInfo.iRegPresent);

	cf->SetConfigBaseAddr(anInfo.iConfigBaseAddr);

	cf->SetConfigOption(anInfo.iConfigOption,aClientID,aFlag);

	__e32_atomic_add_ord32(&iActiveConfigs, 1);

	return(KErrNone);

	}

EXPORT_C void DPcCardSocket::ReleaseConfig(TInt aCardFunc,DBase *aClientID)

//

// Return card to memory only config.

//

	{

	__KTRACE_OPT(KPBUS1,Kern::Printf(">Skt(%d):ReleaseConfig(F:%d)",iSocketNumber,aCardFunc));

	if (IsValidCardFunc(aCardFunc))

		{

		TPcCardFunction *cf=iCardFuncArray[aCardFunc];

		if (cf->IsConfiguredByClient(aClientID))

			{

			if (iState==EPBusOn && Kern::PowerGood())

				WriteConfigReg(aCardFunc,KConfigOptionReg,0); // Restore Config. Option register

			cf->SetConfigRegMask(0);

			cf->SetConfigBaseAddr(0);	

			cf->SetConfigOption(KInvalidConfOpt,NULL,0);

			__e32_atomic_add_ord32(&iActiveConfigs, TUint32(-1));

			}

		}

	}

EXPORT_C TInt DPcCardSocket::ReadConfigReg(TInt aCardFunc,TInt aRegOffset,TUint8 &aVal)

//

// Read from a specified configuration register. (We return an error if the RegPres mask

// indicates the register isn't present but still attempt the read).

//

	{

	TInt offset, err;

	if (!IsValidCardFunc(aCardFunc)|| iState!=EPBusOn || !Kern::PowerGood())

		err=KErrArgument;

	else

		{

		if ((err=iCardFuncArray[aCardFunc]->ConfigRegAddress(aRegOffset,offset))==KErrNone||err==KErrNotSupported)

			{

			TPccdAccessSpeed sp=(VccSetting()==EPccdSocket_3V3)?EAcSpeed600nS:EAcSpeed300nS;

			iAttribWin.SetAccessSpeed(sp);

			iAttribWin.SetupChunkHw();

			iAttribWin.Read(offset,&aVal,1);

			}

		}

	__KTRACE_OPT(KPBUS1,Kern::Printf("<Skt(%d):ReadConfigReg-%d",iSocketNumber,err));

	return(err);

	}

EXPORT_C TInt DPcCardSocket::WriteConfigReg(TInt aCardFunc,TInt aRegOffset,const TUint8 aVal)

//

// Write to a specified configuration register. (We return an error if the RegPres mask

// indicates the register isn't present but still attempt the write).

//

	{

	TInt offset, err;

	if (!IsValidCardFunc(aCardFunc)|| iState!=EPBusOn || !Kern::PowerGood())

		err=KErrArgument;

	else

		{

		if ((err=iCardFuncArray[aCardFunc]->ConfigRegAddress(aRegOffset,offset))==KErrNone||err==KErrNotSupported)

			{

			TPccdAccessSpeed sp=(VccSetting()==EPccdSocket_3V3)?EAcSpeed600nS:EAcSpeed300nS;

			iAttribWin.SetAccessSpeed(sp);

			iAttribWin.SetupChunkHw();

			iAttribWin.Write(offset,&aVal,1);

			}

		}

	__KTRACE_OPT(KPBUS1,Kern::Printf("<Skt(%d):WriteConfigReg-%d",iSocketNumber,err));

	return(err);

	}

const TInt KReadCisBufferSize=0x80;   // 128 Bytes

TInt DPcCardSocket::ReadCis(TPccdMemType aMemType,TInt aPos,TDes8 &aDes,TInt aLen)

//

// Read from CIS 

//

	{

	__KTRACE_OPT(KPBUS2,Kern::Printf(">Skt(%d):ReadCis(LE:%xH PO:%d TY:%d)",iSocketNumber,aLen,aPos,aMemType));

	RPccdWindow newWin;

	RPccdWindow* win=&newWin;

	TBool needNewChunk=ETrue;

	TInt cisE=(aPos+aLen);

	TInt incrm=1;

	if (aMemType==EPccdAttribMem)

		{

		incrm=2;		// Read every other byte

		cisE<<=1;		

		aPos<<=1;

		if (cisE<=(TInt)KDefaultAttribMemSize)

			{

			needNewChunk=EFalse;

			win=&iAttribWin;

			}

		}

	if (needNewChunk)

		{

		TPccdChnk chnk(aMemType,aPos,(cisE-aPos));

		TInt r=newWin.Create(this,chnk,EAcSpeed300nS,KPccdChunkShared|KPccdChunkSystemOwned);

		if (r!=KErrNone)

			return(r);

		cisE-=aPos;

		aPos=0;

		}

	TPccdAccessSpeed sp=(VccSetting()==EPccdSocket_3V3)?EAcSpeed600nS:EAcSpeed300nS;

	win->SetAccessSpeed(sp);

	win->SetupChunkHw();

	aDes.Zero();

	TText8 buf[KReadCisBufferSize];

	TInt s;

	for (;aPos<cisE;aPos+=s)

		{

		s=Min(KReadCisBufferSize,(cisE-aPos));

		win->Read(aPos,&buf[0],s);

		for (TInt i=0;i<s;i+=incrm)

			aDes.Append((TChar)buf[i]);   

		} 

	if (needNewChunk)

		newWin.Close();

	return(KErrNone);

	}

TInt DPcCardSocket::AddNewFunc(TUint32 anOffset,TPccdMemType aMemType)

//

// Create a new card function and append it to the function array

//

	{

	__KTRACE_OPT(KPBUS1,Kern::Printf(">Skt(%d):AddNewFunc(T:%d)",iSocketNumber,aMemType));

	TInt r=KErrNoMemory;

	TPcCardFunction* cf=new TPcCardFunction(anOffset,aMemType);

	if (cf)

		{

		r=iCardFuncArray.Append(cf);

		if (r!=KErrNone)

			delete cf;

		}

	return r;

	}

TPcCardFunction *DPcCardSocket::CardFunc(TInt aCardFunc)

// 

// Get a reference to a specific card function from the function array 

//

	{

	__ASSERT_ALWAYS(IsValidCardFunc(aCardFunc),PcCardPanic(EPcCardBadFunctionNumber));

	return iCardFuncArray[aCardFunc];

	}

TBool DPcCardSocket::IsConfigLocked()

//

// Returns ETrue if this socket contains a card function which is currently configured.

//

	{

//	TInt i;

//	for (i=CardFuncCount()-1;i>=0;i--)

//		{

//		if (iCardFuncArray[i]->IsConfigured())

//			return(ETrue);

//		}

//	return(EFalse);

	return (iActiveConfigs!=0);

	}

TBool DPcCardSocket::IsMemoryLocked()

//

// Returns ETrue if any PC Card memory chunks are allocated on this socket.

//

	{

//	TInt i;

//	for (i=iMemChunks.Count()-1;i>=0;i--)

//		{

//		if ( iMemChunks[i]->IsLocked() )

//			return(ETrue);

//		}

//	return(EFalse);

	return (iClientWindows!=0);

	}

TPccdSocketVcc DPcCardSocket::VccSetting()

//

// Return voltage setting that this socket is currently set for

//

	{

	return ((DPcCardVcc*)iVcc)->VoltageSetting();

	}

EXPORT_C TInt DPcCardSocket::VerifyCard(TPccdType &aType)

//

// Return information about the type of card present 

//

	{

	__KTRACE_OPT(KPBUS1,Kern::Printf(">Cntrl:VerifyCard(S:%d)",iSocketNumber));

	// The data we want is stored off-card, so it doesn't actually need to be

	// powered but we need to have read CIS format.

	TInt err=KErrNone;

    if (CardIsReadyAndVerified()==KErrNone)

		{

		aType.iFuncCount=CardFuncCount();

		for (TInt i=(aType.iFuncCount-1);i>=0;i--)

			aType.iFuncType[i]=CardFunc(i)->FuncType();

		}

	else

		err=KErrNotReady;

	__KTRACE_OPT(KPBUS1,Kern::Printf("<Cntrl:VerifyCard(S:%d T:%d)-%d",iSocketNumber,(TInt)aType.iFuncType[0],err));

	return(err);

	}

TInt DPcCardSocket::CardIsReadyAndVerified()

//

// Returns KErrNone when specified card is powered and ready (ie has had h/w reset) and

// a basic parsing of CIS has been performed (card functions detected).

//

	{

	TInt r=KErrNotReady;

	if (CardIsReady())

		{

		r=KErrNone;

		// Check if card function(s) have been determined (there is always at

		// least a global function record if basic parsing performed).

		if (!IsVerified())

			r=GetCisFormat();

		}

	__KTRACE_OPT(KPBUS1,Kern::Printf("<Cntrl:CardRdyAndVerif(S:%d)-%xH",iSocketNumber,r));

	return r;

	}

TBool DPcCardSocket::CardIsReady()

	{

	TBool r=(iState==EPBusOn && Kern::PowerGood());

	__KTRACE_OPT(KPBUS1,Kern::Printf("CardIsReady: %d",r));

	return r;

	}

TBool DPcCardSocket::CardIsPowered()

	{

	return !iVcc->IsOff();

	}

TInt DPcCardSocket::GetCisFormat()

//

// Determine the type of card present by parsing the entire CIS. If a 

// Multi-function card is present then parse each CIS.

//