// 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\spccard.cpp

// 

//

#include <pccard.h>

#include "cis.h"

LOCAL_D const TPccdAccessSpeed CisDevSpeedTable[8] =

	{EAcSpeedInValid,EAcSpeed250nS,EAcSpeed200nS,EAcSpeed150nS,

	EAcSpeed100nS,EAcSpeedInValid,EAcSpeedInValid,EAcSpeedInValid};

LOCAL_D const TUint32 CisDevSizeInBytesTable[8] =

	{0x00000200,0x00000800,0x00002000,0x00008000,0x00020000,0x00080000,0x00200000,0};

LOCAL_D const TInt CisMantisaTable[0x10] =

	{10,12,13,15,20,25,30,35,40,45,50,55,60,70,80,90};

LOCAL_D const TInt CisSpeedExponentTable[8] =

	{0,1,10,100,1000,10000,100000,1000000};

GLDEF_C void PcCardPanic(TPcCardPanic aPanic)

	{

	Kern::Fault("PCCARD",aPanic);

	}

LOCAL_C TPccdAccessSpeed DevSpeedFromExtended(TInt aSpeedInNanoSecs)

	{

	if (aSpeedInNanoSecs<=100) return(EAcSpeed100nS);

	if (aSpeedInNanoSecs<=150) return(EAcSpeed150nS);

	if (aSpeedInNanoSecs<=200) return(EAcSpeed200nS);

	if (aSpeedInNanoSecs<=250) return(EAcSpeed250nS);

	if (aSpeedInNanoSecs<=300) return(EAcSpeed300nS);

	if (aSpeedInNanoSecs<=450) return(EAcSpeed450nS);

	if (aSpeedInNanoSecs<=600) return(EAcSpeed600nS);

	if (aSpeedInNanoSecs<=750) return(EAcSpeed750nS);

	return(EAcSpeedExtended);

	}

LOCAL_C TMemDeviceType DevType(TInt aTypeCode)

	{

	if ( aTypeCode>=KTpDiDTypeNull && aTypeCode<=KTpDiDTypeDram )

		return( (TMemDeviceType)aTypeCode );

	else if (aTypeCode>=KTpDiDTypeFuncSpec)

		return(EDeviceFunSpec);

	else

		return(EDeviceInvalid);

	}

LOCAL_C TInt ExtendedSpeedToNanoSeconds(TUint8 aVal)

//

// Converts extended device speed field to speed in nS.

//

	{

	TInt mant=(aVal&KCisTplMantM)>>KCisTplMantFO;

	TInt s=(mant==0)?0:CisMantisaTable[mant-1];

	s*=CisSpeedExponentTable[aVal&KCisTplExponM];

	return(s);

	}

LOCAL_C TInt PwrTplToMicroAmps(TUint aVal,TUint anExt)

//

// Converts a power tuple into an integer value - units uA.

//

	{

	TInt p=CisMantisaTable[(aVal&KCisTplMantM)>>KCisTplMantFO];

	p*=10;

	if (anExt<=99)

		p+=anExt;	// Add on the extension

	switch ( aVal&KCisTplExponM )

		{

		case 7: return(p*=10000);   case 6: return(p*=1000); 

		case 5: return(p*=100);	 	case 4: return(p*=10); 

		case 3: return(p);  		case 2: return(p/=10);

		case 1: return(p/=100);

		default: return(0); // Anything else is too small to worry about 

		}

	}

LOCAL_C TInt PwrTplToMilliVolts(TUint aVal,TUint anExt)

//

// Converts a power tuple into a integer value - units mV.

//

	{

	return(PwrTplToMicroAmps(aVal,anExt)/10);

	}

LOCAL_C TInt ParseConfigTuple(TDes8 &configTpl,TPcCardConfig &anInfo,TInt &aLastEntry)

//

// Parse a KCisTplConfig tuple.

// (Always alters iConfigBaseAddr and iRegPresent).  

//

	{

	anInfo.iConfigBaseAddr=0;

	anInfo.iRegPresent=0;

	// Get the sizes of the ConfReg base addr & ConfReg present fields

	TInt rasz=((configTpl[2]&KTpCcRaszM)>>KTpCcRaszFO)+1;

	TInt rmsz=((configTpl[2]&KTpCcRmszM)>>KTpCcRmszFO)+1;

	if ( (configTpl.Size()-4) < (rasz+rmsz) )

		return(KErrNotSupported); // Size of fields longer than tuple length.

	aLastEntry=configTpl[3];

	// Read Config. Reg. base address.

	TInt i;

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

		anInfo.iConfigBaseAddr += (configTpl[4+i]<<(8*i));

	// Read Config. Reg. present mask

	if (rmsz>4) rmsz=4;	  // We only have 32bit field

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

		anInfo.iRegPresent += (configTpl[4+rasz+i]<<(8*i));

	return(KErrNone); // Ignore custom interface subtuples

	}

LOCAL_C TInt ParsePowerEntry(const TUint8 *aTplPtr,TInt *aVMax,TInt *aVMin,TInt *aPeakI,TInt *aPdwnI)

//

// Parse a Power descriptor in a KCisTplCfTableEntry tuple. Returns the 

// number of bytes we have parsed. 

//

	{

	const TUint8 *initPtr = aTplPtr;

	TUint8 present = *aTplPtr++;

	TBuf8<16> pwr;

	pwr.FillZ(16);	  // Important

	TInt i;

	for (i=0;i<16;i+=2,present>>=1)

		{

		if (present&0x01)

			{

			pwr[i]=(TUint8)((*aTplPtr)&(~KCisTplExt));

			if (*aTplPtr++ & KCisTplExt)

				{

				pwr[i+1]=(TUint8)((*aTplPtr)&(~KCisTplExt));	// Extension tuple

				while( *aTplPtr++ & KCisTplExt );				// Jump past any more extensions

				}

			}

		}

	if (aVMin && aVMax)

		{

		if (pwr[0])						 // NomV (assume +/-5%)

			{

			(*aVMin)=(*aVMax)=PwrTplToMilliVolts(pwr[0],pwr[1]);

			(*aVMin) = ((*aVMin)*95)/100;

			(*aVMax) = ((*aVMax)*105)/100;

			}

		if (pwr[2])							// MinV

			*aVMin=PwrTplToMilliVolts(pwr[2],pwr[3]);

  		if (pwr[4])							// MaxV

			*aVMax=PwrTplToMilliVolts(pwr[4],pwr[5]);

		}

	// We'll settle for average/static if no peak.

	if (aPeakI && (pwr[10]||pwr[8]||pwr[6]) )

		{

		if (pwr[6])

			*aPeakI = PwrTplToMicroAmps(pwr[6],pwr[7]);

		if (pwr[8])

			*aPeakI = PwrTplToMicroAmps(pwr[8],pwr[9]);

		if (pwr[10])

			*aPeakI = PwrTplToMicroAmps(pwr[10],pwr[11]); // Last one overides others

		}

	if (aPdwnI && pwr[12])

		*aPdwnI = PwrTplToMicroAmps(pwr[12],pwr[13]); 

	return(aTplPtr-initPtr);

	}

LOCAL_C TInt ParseTimingEntry(const TUint8 *aTplPtr)

//

// Parse a timing descriptor in a KCisTplCfTableEntry tuple. Returns the 

// number of bytes we have parsed. 

//

	{

	// We ignore this information - just jump past this field

	const TUint8 *initPtr=aTplPtr;

	TUint8 present=*aTplPtr++;	  // First the timing present field

	if ((present & KTpCeTimWaitM) != KTpCeTimWaitM)

		while( *aTplPtr++ & KCisTplExt ); // Wait time (jump past any extensions)

	if ((present & KTpCeTimRdyM) != KTpCeTimRdyM)

		while( *aTplPtr++ & KCisTplExt ); // Ready time (jump past any extensions)

	if ((present & KTpCeTimResM) != KTpCeTimResM)

		while( *aTplPtr++ & KCisTplExt ); // Reserved time (jump past any extensions)

	return(aTplPtr-initPtr);

	}

LOCAL_C TInt ParseIoEntry(const TUint8 *aTplPtr,TPccdChnk *aChnk,TInt &aNextChnkNum)

//

// Parse an IO space descriptor in a KCisTplCfTableEntry tuple. Returns the 

// number of bytes we have parsed (or a negative error value). Also returns the 

// number of config chunk entries used ('aNextChunkNum').

//

	{

	TPccdMemType memType;

	TInt bytesParsed = 1; // Must be a minimum of a single byte descriptor here.

	// Always at least one I/O space descriptor

	switch( (*aTplPtr & KTpCeBus16_8M) >> KTpCeBus16_8FO )

		{

		case 1: case 2:

			memType = EPccdIo8Mem;	 // Card supports 8bit I/O only.

			break;

		case 3:

			memType = EPccdIo16Mem;	// Card supports 8 & 16 bit I/O.

			break;

		default:

			return(KErrCorrupt);	

		}

	TUint ioLines = (*aTplPtr & KTpCeIoLinesM) >> KTpCeIoLinesFO;

	TInt ranges=1; // We always specify one chunk even if no range descriptors follow

	TInt addrInBytes=0; 

	TInt lenInBytes=0;

	// Are there any IO Range description bytes to follow

	if (*aTplPtr++ & KTpCeRangePresM)

		{

		ranges = ((*aTplPtr & KTpCeIoRangesM) >> KTpCeIoRangesFO)+1;

		addrInBytes = (*aTplPtr & KTpCeIoAddrSzM) >> KTpCeIoAddrSzFO;

		lenInBytes = (*aTplPtr & KTpCeIoAddrLenM) >> KTpCeIoAddrLenFO;

		aTplPtr++;

		// There could be multiple range descriptors

		if ((ranges+aNextChnkNum)<=KMaxChunksPerConfig)

			bytesParsed += (ranges * (addrInBytes + lenInBytes))+1;

		else

			return(KErrNotSupported);	// Too many descriptors for us

		}

	aChnk+=aNextChnkNum;

	for (;ranges>0;ranges--,aChnk++,aNextChnkNum++)

		{

		TInt j;

		aChnk->iMemType=memType;	 // I/O memory type

		// Lets get the IO start address

		aChnk->iMemBaseAddr=0;

		if (addrInBytes)

			{

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

				aChnk->iMemBaseAddr += (*aTplPtr++) << (8*j);

			}

		// Finally, lets get the IO length

		if (lenInBytes)

			{

			for (j=0,aChnk->iMemLen=0;j<lenInBytes;j++)

		   		aChnk->iMemLen += (*aTplPtr++) << (8*j);

			(aChnk->iMemLen)++;

			}

		else

			{

			if (ioLines)

				aChnk->iMemLen = 0x01<<ioLines;

			else

				return(KErrCorrupt); // No ioLines and no length, it's invalid.   

			}

		}

	return(bytesParsed);

	}

LOCAL_C TInt ParseMemEntry(const TUint8 *aTplPtr,TInt aFeatureVal,TPccdChnk *aChnk,TInt &aNextChnkNum)

//

// Parse a memory space descriptor in a KCisTplCfTableEntry tuple. Returns

// the number of bytes we have parsed (or a negative error value). Also returns the 

// number of config chunk entries used ('aNextChunkNum').

//

	{

	const TUint8 *initPtr=aTplPtr;

	TInt windows=0; 		

	TInt lenInBytes=0;  	

	TInt addrInBytes=0;		

	TBool hostAddr=EFalse;

	switch (aFeatureVal)

		{

		case 3:   // Memory space descriptor

			windows=(*aTplPtr & KTpCeMemWindowsM)+1;

			lenInBytes=(*aTplPtr & KTpCeMemLenSzM) >> KTpCeMemLenSzFO;

			addrInBytes=(*aTplPtr & KTpCeMemAddrSzM) >> KTpCeMemAddrSzFO;

			hostAddr=(*aTplPtr & KTpCeMemHostAddrM);

			aTplPtr++;

			break;

		case 2:			// Length(2byte) and base address(2byte) specified.

			addrInBytes=2; 

		case 1:			// Single 2-byte length specified.

			lenInBytes=2;

			windows=1;

			break;

		}

	if ((windows+aNextChnkNum)>KMaxChunksPerConfig)

		return(KErrNotSupported);	// Too many descriptors for us

	aChnk+=aNextChnkNum;

	TInt i;

	for (;windows>0;windows--,aChnk++,aNextChnkNum++)

		{

		aChnk->iMemType=EPccdCommon16Mem;

		aChnk->iMemLen=0;

		if (lenInBytes)

			{

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

				aChnk->iMemLen += (*aTplPtr++) << ((8*i)+8);  	// in 256 byte pages

			}

		aChnk->iMemBaseAddr=0;

		if (addrInBytes)

			{

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

				aChnk->iMemBaseAddr += (*aTplPtr++) << ((8*i)+8);// in 256 byte pages

			}

		if (hostAddr)

			{

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

				aTplPtr++; // Dont record this, just advance the tuple pointer

			}

		}

	return(aTplPtr-initPtr);

	}

LOCAL_C TInt ParseMiscEntry(const TUint8 *aTplPtr, TBool &aPwrDown)

//

// Parse a miscellaneous features field in a KCisTplCfTableEntry tuple.

// Returns the number of bytes we have parsed. 

//

	{

	aPwrDown=(*aTplPtr&KTpCePwrDownM);

	TInt i;

	for (i=1;*aTplPtr & KCisTplExt;i++,aTplPtr++);

	return(i);

	}

LOCAL_C TInt ParseConfigEntTuple(TDes8 &cTpl,TPcCardConfig &anInfo)

//

// Parse a KCisTplCfTableEntry tuple. anInfo contains default values on 

// entry so this routine only adds data it finds in the tuple.

//

	{

	// Parse the Index byte.

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

	anInfo.iConfigOption=(*tplPtr & KTpCeOptionM);

	anInfo.iIsDefault=(*tplPtr & KTpCeIsDefaultM);

	// Check if there is an interface description field to follow

	if (*tplPtr++ & KTpCeIntfPresM)

		{

 		anInfo.iIsIoAndMem=(*tplPtr&KTpCeIntfTypeM);

		anInfo.iActiveSignals=*tplPtr&(KTpCeBvdM|KTpCeWpM|KTpCeReadyM|KTpCeWaitM);

		tplPtr++;

		}

	// Next byte should be the feature selection byte.

	TUint8 features=*tplPtr++;

	// Next might be 0-3 power description structures. 1st one is always VCC info.

	TInt entry=(features & KTpCePwrPresM)>>KTpCePwrPresFO;

	if (entry)

		{

		tplPtr += ParsePowerEntry(tplPtr,&anInfo.iVccMaxInMilliVolts,&anInfo.iVccMinInMilliVolts,

							      &anInfo.iOperCurrentInMicroAmps,&anInfo.iPwrDwnCurrentInMicroAmps);

		entry--;

		}

	// We only support a single Vpp supply. However we need to parse both (Vpp1+Vpp2)

	// in order to advance the tuple pointer.

	while ( entry-- )

		tplPtr += ParsePowerEntry(tplPtr,&anInfo.iVppMaxInMilliVolts,&anInfo.iVppMinInMilliVolts,NULL,NULL);

	// Next might be timing info.

	if (features & KTpCeTimPresM)

		tplPtr += ParseTimingEntry(tplPtr);

	// Next might be IO space description.

	TInt ret;

	TInt nextFreeChunk=0;

	if (features & KTpCeIoPresM)

		{

		if((ret=ParseIoEntry(tplPtr,&(anInfo.iChnk[0]),nextFreeChunk))<0)

			return(ret);

		anInfo.iValidChunks=nextFreeChunk;

		tplPtr += ret;

		}

	// Next might be IRQ description.

	if (features & KTpCeIrqPresM)

		{

		anInfo.iInterruptInfo=*tplPtr&(KPccdIntShare|KPccdIntPulse|KPccdIntLevel);

		tplPtr+=(*tplPtr&KTpCeIrqMaskM)?3:1; // Ignore mask bytes if present

		}

	// Next might be memory space description.

	entry=((features & KTpCeMemPresM) >> KTpCeMemPresFO);

	if (entry)

		{

		if ((ret=ParseMemEntry(tplPtr,entry,&(anInfo.iChnk[0]),nextFreeChunk))<0)

			return(ret);

		anInfo.iValidChunks=nextFreeChunk;

		tplPtr+=ret;

		}

	// And finally there might be a miscellaneous features field

	if (features & KTpCeMiscPresM)

		tplPtr+=ParseMiscEntry(tplPtr,anInfo.iPwrDown);

	// Check that we haven't been reading beyond the tuple.

	if ((tplPtr-cTpl.Ptr()) > (cTpl[1]+2))

		return(KErrCorrupt);

	return(KErrNone);

	}

LOCAL_C TInt ParseDeviceInfo(const TUint8 *aTplPtr,TPcCardRegion &anInfo)

//

// Parse a device info field in a KCisTplDeviceX tuple.

// Returns the number of bytes we have parsed (or a negative error value). 

//

	{

	const TUint8 *initPtr=aTplPtr;

	TInt val;

	// Device ID - device type field

	val=((*aTplPtr & KTpDiDTypeM) >> KTpDiDTypeFO);

	if (val==KTpDiDTypeExtend)

		return(KErrNotSupported);	   // Don't support extended device type

	anInfo.iDeviceType=DevType(val);

	// Device ID - write protect field

	if (!(*aTplPtr&KTpDiWpsM))

		anInfo.iActiveSignals|=KSigWpActive;

	// Device ID - device speed field

	val=(*aTplPtr & KTpDiDSpeedM);

	if (val==KTpDiDSpeedExt)

		{

		aTplPtr++;

		anInfo.iExtendedAccSpeedInNanoSecs=ExtendedSpeedToNanoSeconds(*aTplPtr);

		anInfo.iAccessSpeed=DevSpeedFromExtended(anInfo.iExtendedAccSpeedInNanoSecs);

		while(*aTplPtr++ & KCisTplExt); // Jump past any (further) extended speed fields

		}

	else

		{

		anInfo.iExtendedAccSpeedInNanoSecs=0;

		anInfo.iAccessSpeed=CisDevSpeedTable[val];

		aTplPtr++;

		}

	// Now the Device size

	TInt size,numUnits;

	size=((*aTplPtr & KTpDiDSizeM) >> KTpDiDSizeFO);

	numUnits=((*aTplPtr++ & KTpDiDUnitsM) >> KTpDiDUnitsFO)+1;

	if (size>KTpDiDSize2M)

		return(KErrCorrupt);	 

	anInfo.iChnk.iMemLen=numUnits*CisDevSizeInBytesTable[size];

	return(aTplPtr-initPtr);

	}

/*

LOCAL_C TInt SocketIsInRange(TSocket aSocket)

//

// Check socket is valid for this machine

//

	{

//	return(aSocket>=0&&aSocket<ThePcCardController->TotalSupportedBuses());

	return (aSocket>=0 && aSocket<KMaxPBusSockets && TheSockets[aSocket]!=NULL);

	}

*/

EXPORT_C TCisReader::TCisReader()

//

// Constructor.

//

	: iFunc(0),iCisOffset(0),iLinkOffset(0),iMemType(EPccdAttribMem),

	  iLinkFlags(0),iRestarted(EFalse),iRegionCount(0),

	  iConfigCount(0)

	{

	iSocket=NULL;

	}

EXPORT_C TInt TCisReader::SelectCis(TSocket aSocket,TInt aCardFunc)

//

//  Assign the CIS reader to a socket and function.

//

	{

	// We need to have read the CIS format

	__KTRACE_OPT(KPBUS1,Kern::Printf(">CisReader:SelectCis(S:%d F:%d)",aSocket,aCardFunc));

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

	if (pS->CardIsReadyAndVerified()!=KErrNone)

		return KErrNotReady;

	iSocket=pS;

	return(DoSelectCis(aCardFunc));

	}

TInt TCisReader::DoSelectCis(TInt aCardFunc)

//

//  Actually assign the CIS reader to a socket and function.

//

	{

	// Check that the function is valid

	TInt r;

	if (!iSocket->IsValidCardFunc(aCardFunc))

		{

		iSocket=NULL;

		r=KErrNotFound;

		}

	else

		{

		iFunc=aCardFunc;

		DoRestart();

		iConfigCount=0;

		r=KErrNone;

		}

	__KTRACE_OPT(KPBUS1,Kern::Printf("<CisReader:DoSelectCis(F:%d)-%d",aCardFunc,r));