// 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);

 	}