// 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.

//

	{

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

	TInt r=AddNewFunc(0,EPccdAttribMem);		// We always have 1st CIS

	if (r!=KErrNone)

		return r;

	if (ValidateCis(0)!=KErrNone)				// Can't use this until func added

		return KErrCorrupt;

	TCisReader cisRd;

	cisRd.iSocket=this;

	cisRd.DoSelectCis(0);

	TPccdFuncType firstFuncType;

	// Check for a multi-function card, search the global CIS (attribute 

	// memory - addr 0) for a KCisTplLongLinkMfc tuple.

	TBuf8<KLargeTplBufSize> tpl;

	if (cisRd.DoFindReadTuple(KCisTplLongLinkMfc,tpl,KPccdReturnLinkTpl)==KErrNone)

		{

		// Multi-Function card 

		firstFuncType=EGlobalCard;

		const TUint8 *tplPtr=tpl.Ptr()+2; // First tuple after link

		TInt funcCount=*tplPtr++;

		// Add a card function object to the socket for each entry in KCisTplLongLinkMfc tuple

		TPccdMemType memType;

		TUint32 lnkAdr;

		TInt i;

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

			{

			memType=(*tplPtr++)?EPccdCommon8Mem:EPccdAttribMem;

			TInt j;

			for (lnkAdr=0,j=0;j<4;j++)		// Convert link address from string to unsigned long

				lnkAdr += (*tplPtr++) << (8*j);

			r=AddNewFunc(lnkAdr,memType);

			if (r!=KErrNone)

				return r;

			if (ValidateCis(i+1)!=KErrNone) // Can't use this until func added

				return KErrCorrupt;

			}

		// Parse the CIS of each card function looking for a KCisTplFuncId tuple

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

			{

			cisRd.DoSelectCis(i);

			TPccdFuncType ft;

			if (cisRd.DoFindReadTuple(KCisTplFuncId,tpl,0)==KErrNone)

				ft=FuncType(tpl[2]);

			else

				ft=EUnknownCard;

			CardFunc(i)->SetFuncType(ft);

			}

		}

	else

		{

		// Single Function card 

		cisRd.Restart();

		if (cisRd.DoFindReadTuple(KCisTplFuncId,tpl,0)==KErrNone)

			firstFuncType=FuncType(tpl[2]); 

		else

			firstFuncType=EUnknownCard; 

		}

	CardFunc(0)->SetFuncType(firstFuncType);

	__KTRACE_OPT(KPBUS1,Kern::Printf("<GetCisFormat(T:%d)",firstFuncType));

	return KErrNone;

	}

TInt DPcCardSocket::ValidateCis(TInt aCardFunc)

//

// Attempt to walk though entire CIS.

//

	{

	TCisReader cisRd;

	cisRd.iSocket=this;

	TBuf8<KLargeTplBufSize> tpl;

	TInt j=0,err;

	if ((err=cisRd.DoSelectCis(aCardFunc))==KErrNone)

		{

		for (j=0;j<KMaxTuplesPerCis;j++)

			{

			err=cisRd.DoFindReadTuple(KPccdNonSpecificTpl,tpl,(KPccdFindOnly|KPccdReturnLinkTpl|KPccdReportErrors));

			if (err!=KErrNone)

				break;

			}

		if (j>=KMaxTuplesPerCis)

			err=KErrCorrupt;

		if (err==KErrNotFound)

			err=KErrNone;

		}

	__KTRACE_OPT(KPBUS1,Kern::Printf("<Skt:ValidateCis(S:%d F:%d Tuples:%d)-%d",iSocketNumber,aCardFunc,j,err));

	return(err);

	}

void DPcCardSocket::InitiatePowerUpSequence()

	{

	__KTRACE_OPT(KPBUS1,Kern::Printf("DPcCardSocket(%d)::InitiatePowerUpSequence",iSocketNumber));

	// Check if battery is too low

//	TSupplyStatus ss=(TSupplyStatus)iMachineInfo.iDisableOnLowBattery;

//	if (ss!=EZero)

//		{

//		TSupplyInfoV1 info;

//		Hal::SupplyInfo(info); 

//		if (info.iMainBatteryStatus<ss && !info.iExternalPowerPresent)

//			{

//			iSocket[aSocket]->SetSocketStatus(ESocketBatTooLow);

//			rs=KErrBadPower;

//			break;

//			}

//		}

	// Check the state of the Voltage sense line

	TSocketIndicators ind;

	Indicators(ind);

	TUint v=(TUint)ind.iVoltSense & ((DPcCardVcc*)iVcc)->VoltageSupported();

	if (v==0)

		{

		__KTRACE_OPT(KPBUS1,Kern::Printf("InitiatePowerUpSequence(S:%d)-Voltage sense problem(%d)",iSocketNumber,ind.iVoltSense));

		iVcc->SetCurrLimited();   // Not totally true but has effect.

		PowerUpSequenceComplete(KErrCorrupt);

		return;

		}

	TPccdSocketVcc sVcc=(v&KPccdVcc_3V3)?EPccdSocket_3V3:EPccdSocket_5V0; // ??? What about xVx / yVy 

	((DPcCardVcc*)iVcc)->SetVoltage(sVcc);

	// Power up card (current limited).

	__KTRACE_OPT(KPBUS1,Kern::Printf("InitiatePowerUpSequence(S:%d)-Apply Vcc",iSocketNumber));

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

		{

		__KTRACE_OPT(KPBUS1,Kern::Printf("InitiatePowerUpSequence(S:%d)-Vcc problem",iSocketNumber));

		iVcc->SetState(EPsuOff);

		iVcc->SetCurrLimited();

		PowerUpSequenceComplete(KErrGeneral);

		return;

		}

	iCardPowerUpState=EInit;

	iCardPowerUpTickCount=0;

	iCardPowerUpResetLen=KResetOnDefaultLen;

	iCardPowerUpPauseLen=KResetOffDefaultLen;

	iCardPowerUpTimer.Periodic(KPccdPowerUpReqInterval,cardPowerUpTick,this);

	}

void DPcCardSocket::TerminatePowerUpSequence(TInt aResult)

	{

	__KTRACE_OPT(KPBUS1,Kern::Printf("DPcCardSocket(%d)::TerminatePowerUpSequence result %d",iSocketNumber,aResult));

	ResetPowerUpState();

	if (aResult==KErrNone)

		Restore();

	PowerUpSequenceComplete(aResult);

	}

void DPcCardSocket::CardPowerUpTick()

	{

	__KTRACE_OPT(KPBUS1,Kern::Printf("CardPowerUpTick S:%d Elapsed %d State %d",iSocketNumber,iCardPowerUpTickCount,iCardPowerUpState));

	if (++iCardPowerUpTickCount>KPwrUpTimeOut)

		{

		iVcc->SetState(EPsuOff);	// should leave this to timeout

		TerminatePowerUpSequence(KErrTimedOut);

		return;

		}

	switch (iCardPowerUpState)

		{

		case EInit:

			HwReset(ETrue);		// Apply reset - Turns on interface

			iCardPowerUpState=EApplyingReset;

			break;

		case EApplyingReset:

			if (iCardPowerUpTickCount>iCardPowerUpResetLen)

				{

				HwReset(EFalse);	// remove reset

				iCardPowerUpState=ECheckVcc;

				}

			break;

		case ECheckVcc:

			{

			iCardPowerUpState=EWaitForVccReading;

			TInt cv=iVcc->CheckVoltage(KPsuChkOnPwrUp);

			if (cv==KErrNotSupported)

				iCardPowerUpState=EWaitForReady;

			else if (cv!=KErrNone)

				TerminatePowerUpSequence(cv);

			break;

			}

		case EWaitForVccReading:

			break;

		case EWaitForReady:

			if (Ready())

				{

				iCardPowerUpState=EPauseAfterReady; // Card is ready

				// Its effectively powered up now so reset the elapsed time and use it 

				// to measure pause after reset (ie this is limited to KPwrUpTimeOut too).

				iCardPowerUpTickCount=0;

				}

			break;

		case EPauseAfterReady:

			if (iCardPowerUpTickCount>=iCardPowerUpPauseLen)

				{

				// power-up sequence is complete

				TerminatePowerUpSequence(KErrNone);

				}

			break;

		}

	}

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

 * PC card memory chunk

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

DPccdChunkBase::DPccdChunkBase()

//

// Constructor

//

	{

//	iSocket=NULL;

//	iCacheable=EFalse;

	}

TInt DPccdChunkBase::Create(DPcCardSocket* aSocket, TPccdChnk aChunk, TUint aFlag)

//

// Create a chunk of Pc Card h/w.

//

	{

	iSocket=aSocket;

	iChnk=aChunk;

	iCacheable=(aFlag&KPccdChunkCacheable);

	return DoCreate(aChunk,aFlag);

	}

DPccdChunkBase::~DPccdChunkBase()

//

// Destructor

//

	{

	__KTRACE_OPT(KPBUS1,Kern::Printf(">DPccdChunkBase destruct %08x",this));

	}

void DPccdChunkBase::Close()

//

// Destructor

//

	{

	__KTRACE_OPT(KPBUS1,Kern::Printf(">DPccdChunkBase::Close() %08x",this));

	// Disconnect all the Pc Card windows and then delete chunk

	SDblQueLink* pW=iWindowQ.iA.iNext;

	while (pW!=&iWindowQ.iA)

		{

		RPccdWindow& w=*(RPccdWindow*)pW;

		pW=pW->iNext;

		w.Close();	// closing last window deletes chunk

		}

	__KTRACE_OPT(KPBUS1,Kern::Printf("<DPccdChunkBase::Close() %08x",this));

	}

TBool DPccdChunkBase::IsRemovable()

//

// Check if this chunk has any permanent windows.

//

	{

	return (iPermanentWindows==0);

	}

TBool DPccdChunkBase::IsLocked()

//

// Check if this chunk has any windows which are allocated to clients of the PC Card

// Controller (as opposed to the Controller itself).

//

	{

	return (iWindows>iSystemWindows);

	}

TInt DPccdChunkBase::AllocateWinCheck(TPccdChnk aWin,TUint aFlag)

//

// Check if it is possible to create the specified window from this chunk.

//

	{

	// Check if they are of compatible type

	if (!IsTypeCompatible(aWin.iMemType))

		return(KErrNotFound);

	// For a success, the requested window must lie entirely within this chunk.

	TUint32 chnkEnd=(iChnk.iMemBaseAddr+iChnk.iMemLen-1);

	TUint32 winEnd=(aWin.iMemBaseAddr+aWin.iMemLen-1);

	TBool startIsInChnk=(aWin.iMemBaseAddr>=iChnk.iMemBaseAddr && aWin.iMemBaseAddr<=chnkEnd);

	TBool endIsInChnk=(winEnd>=iChnk.iMemBaseAddr && winEnd<=chnkEnd);

	if (startIsInChnk&&endIsInChnk)

		{

		// Possible success - first check the cache options are compatible

		if (!(aFlag|KPccdChunkCacheable)&&iCacheable)

			return(KErrAccessDenied);

		// Now check that the requested window isn't already allocated

		SDblQueLink* pW=iWindowQ.iA.iNext;

		while (pW!=&iWindowQ.iA)

			{

			RPccdWindow& w=*(RPccdWindow*)pW;

			pW=pW->iNext;

			if (w.Overlap(aWin.iMemBaseAddr-iChnk.iMemBaseAddr,aWin.iMemLen) )

				return(KErrAccessDenied);

			}

		return(KErrNone);

		}

	if (startIsInChnk||endIsInChnk)

		return(KErrAccessDenied);	// Requested window is partly in this chunk.

	return(KErrNotFound);

	}

void DPccdChunkBase::AddWindow(RPccdWindow *aWindow)

//

// Add a window to this chunk.

//

	{

	iWindowQ.Add(aWindow);

//	Kern::EnterCS();		Not needed since a single thread is used

	iWindows++;

	if (aWindow->IsPermanent())

		iPermanentWindows++;

	if (aWindow->IsShareable())

		iShareableWindows++;

	if (aWindow->IsSystemOwned())

		iSystemWindows++;

	else

		iSocket->iClientWindows++;

//	Kern::LeaveCS();

	aWindow->iChunk=this;

	}

void DPccdChunkBase::RemoveWindow(RPccdWindow *aWindow)

//

// Remove a window from this chunk (even if it's permanent). 

//	

	{

	if (aWindow->iNext && aWindow->iChunk==this)

		{

		aWindow->Deque();

		aWindow->iNext=NULL;

//		Kern::EnterCS();	Not needed since a single thread is used

		iWindows--;

		if (aWindow->IsPermanent())

			iPermanentWindows--;

		if (aWindow->IsShareable())

			iShareableWindows--;

		if (aWindow->IsSystemOwned())

			iSystemWindows--;

		else

			iSocket->iClientWindows--;

//		Kern::LeaveCS();

		if (iWindows==0)

			{

			iSocket->RemoveChunk(this);

			delete this;

			}

		}

	}

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

 * PC card memory window

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

EXPORT_C RPccdWindow::RPccdWindow()

//

// Constructor

//

	: iAccessSpeed(EAcSpeedInValid),iMemType(EPccdAttribMem),iOffset(0),iLen(0),iType(0)

	{

	iNext=NULL;

	iChunk=NULL;

	}

EXPORT_C TInt RPccdWindow::Create(DPcCardSocket* aSocket, TPccdChnk aChnk, TPccdAccessSpeed aSpeed, TUint aFlag)

//

// Create a block of memory (IO, Common or Attribute memory).

//

	{

	DPccdChunkBase *chunk=NULL;

	TBool chunkExists=EFalse;

	TInt r;

	// See if requested window is actually part of a chunk already created

	TInt i;

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

		{

		if ((r=aSocket->iMemChunks[i]->AllocateWinCheck(aChnk,aFlag))==KErrNone)

			{

			chunk=aSocket->iMemChunks[i];

			chunkExists=ETrue;

			break;

			}

		if (r==KErrAccessDenied)

			return r;

		}

	// If necesary, create a chunk

	if (!chunkExists)

		{

		// Create the memory chunk

		chunk=aSocket->NewPccdChunk(aChnk.iMemType);

		if (!chunk)

			return KErrNoMemory;

		TInt r=chunk->Create(aSocket, aChnk, aFlag);

		if (r==KErrNone)

			r=aSocket->iMemChunks.Append(chunk);

		if (r!=KErrNone)

			{

			delete chunk;

			return r;

			}

		}

	__KTRACE_OPT(KPBUS2,Kern::Printf("Skt:CreateMemWindowL-got chunk(existing-%d)",chunkExists));

	// Create the memory window

	iOffset=aChnk.iMemBaseAddr-chunk->BaseAddr();

	iLen=aChnk.iMemLen;

	iAccessSpeed=aSpeed;

	iMemType=aChnk.iMemType;

	iWaitSig=(aFlag&KPccdRequestWait);

	iType=aFlag&(KPccdChunkShared|KPccdChunkPermanent|KPccdChunkSystemOwned); // Save flag settings

	chunk->AddWindow(this);

	__KTRACE_OPT(KPBUS2,Kern::Printf("Skt:CreateMemWindowL-created window"));

	return KErrNone;

	}

EXPORT_C void RPccdWindow::Close()

	{

	if (iNext && iChunk)

		iChunk->RemoveWindow(this);

	}

EXPORT_C TInt RPccdWindow::SetupChunkHw(TUint aFlag)

//

// Config h/w in preparation for accessing window. Flag is for platform dependant info.

//

	{

	if (!iChunk)

		return(KErrNotReady);

	iChunk->SetupChunkHw(iAccessSpeed,iMemType,iWaitSig,aFlag);

//	iVcc->ResetInactivityTimer();

	return(KErrNone);

	}

EXPORT_C TLinAddr RPccdWindow::LinearAddress()

//

// Return linear address of window

//

	{

	return iChunk->LinearAddress()+iOffset;

	}

TBool RPccdWindow::Overlap(TUint32 anOffset,TUint aLen)

//

//

//

	{

	// If this window is sharable then it doesn't matter if they overlap or not.

	if (IsShareable())

		return(EFalse);

	TUint32 winEnd=(anOffset+aLen-1);

	TUint32 thisEnd=(iOffset+iLen-1);

	if ((anOffset>=iOffset && anOffset<=thisEnd) ||

		(winEnd>=iOffset && winEnd<=thisEnd) )

		return(ETrue);

	return(EFalse);

	}