diff -r 000000000000 -r cec860690d41 haitest/bspsvs/suite/bsp/mmc/src/T_MmcSDPsuDriverData.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/haitest/bspsvs/suite/bsp/mmc/src/T_MmcSDPsuDriverData.cpp	Tue Feb 02 01:39:10 2010 +0200
@@ -0,0 +1,637 @@
+/*
+* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "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:
+*
+*/
+
+#include "T_MmcSDPsuDriverData.h"
+
+//MMCSD Commands index
+/*@{*/
+
+_LIT(KEnumNull,							" ");
+
+_LIT(KCmdPsuInfo,						"PsuInfo");
+_LIT(KCmdPbusState,						"PbusState");
+_LIT(KCmdSetPsuState,					"SetState");
+_LIT(KCmdVccState,						"VccState");
+_LIT(KCmdPsuVoltage,					"SetVoltage");
+_LIT(KCmdPsuNumber,						"PsuNumber");
+_LIT(KCmdMediaChangeNumber,				"MediaChangeNumber");
+_LIT(KCmdPsuCurLimit,					"PsuCurLimit");
+
+_LIT(KVoltage,							"expectedvoltage");
+_LIT(KCurrent,							"expectedcurrent");
+_LIT(KVoltageinterval,					"expectedvoltageinterval");
+_LIT(KVoltagecheck,						"expectedvoltagecheck");
+_LIT(KInactivityTimeOut,				"expectedpsuinactivitytimeOut");
+_LIT(KNotlockedtimeOut,					"expectednotlockedtimeOut");
+_LIT(KPbusState,						"expectedpbusstate");
+_LIT(KVccState,							"expectedvccstate");
+_LIT(KExpectedpsuNumber,				"expectedpsuNumber");
+_LIT(KExpectedmediaChangeNumber,		"expectedmediaChangeNumber");
+_LIT(KExpectedpsuCurLimit,				"expectedpsuCurLimit");
+
+_LIT(KPsuState,							"psustate");
+_LIT(KPsuVoltage,						"psuVoltage");
+/*@}*/
+
+_LIT(KPsuChkComparator,					"EDPsuChkComparator");
+_LIT(KPsuChkADCType,					"EDPsuChkADCType");
+_LIT(KPsuChkADCType2,					"EDPsuChkADCType2");
+
+_LIT(KBusCardAbsent,					"EBusCardAbsent");
+_LIT(KBusOff,							"EBusOff");
+_LIT(KBusPoweringUp,					"EBusPoweringUp");
+_LIT(KBusOn,							"EBusOn");
+_LIT(KEBusPsuFault,						"EBusPsuFault");
+_LIT(KBusPowerUpPending,				"EBusPowerUpPending");
+
+_LIT(KPsuOff,							"EDPsuOff");
+_LIT(KPsuOnCurLimit,					"EDPsuOnCurLimit");
+_LIT(KPsuOnFull,						"EDPsuOnFull");
+
+const CDataWrapperBase::TEnumEntryTable	CT_MMCSDPsuDriverData::iEnumTableVoltageCheckMethod[] =
+	{
+//	Enum as a descriptor					Enum
+	KPsuChkComparator,						EDPsuChkComparator,
+	KPsuChkADCType,							EDPsuChkADCType,
+	KPsuChkADCType2,						EDPsuChkADCType2,
+	KEnumNull,								-1
+	};
+
+const CDataWrapperBase::TEnumEntryTable	CT_MMCSDPsuDriverData::iEnumTablePbusState[] =
+	{
+//	Enum as a descriptor					Enum
+	KBusCardAbsent,							EBusCardAbsent,
+	KBusOff,								EBusOff,
+	KBusPoweringUp,							EBusPoweringUp,
+	KBusOn,									EBusOn,
+	KEBusPsuFault,							EBusPsuFault,
+	KBusPowerUpPending,						EBusPowerUpPending,
+	KEnumNull,								-1
+	};
+
+const CDataWrapperBase::TEnumEntryTable	CT_MMCSDPsuDriverData::iEnumTableVccState[] =
+	{
+//	Enum as a descriptor					Enum
+	KPsuOff,								EDPsuOff,
+	KPsuOnCurLimit,							EDPsuOnCurLimit,
+	KPsuOnFull,								EDPsuOnFull,
+	KEnumNull,								-1
+	};
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+CT_MMCSDPsuDriverData* CT_MMCSDPsuDriverData::NewL()
+	{
+	CT_MMCSDPsuDriverData*	ret=new (ELeave) CT_MMCSDPsuDriverData();
+	CleanupStack::PushL(ret);
+	ret->ConstructL();
+	CleanupStack::Pop(ret);
+	return ret;
+	}
+
+
+CT_MMCSDPsuDriverData::CT_MMCSDPsuDriverData()
+:	CT_MmcSDDriverData()
+,	iAsyncErrorIndex(0)
+	{
+	}
+
+void CT_MMCSDPsuDriverData::ConstructL()
+/**
+ * Second phase construction
+ *
+ * @internalComponent
+ *
+ * @return	N/A
+ *
+ * @pre		None
+ * @post	None
+ *
+ * @leave	system wide error
+ */
+	{
+	CT_MmcSDDriverData::ConstructL();
+	}
+
+CT_MMCSDPsuDriverData::~CT_MMCSDPsuDriverData()
+/**
+ * Public destructor
+ */
+	{
+	}
+
+TBool CT_MMCSDPsuDriverData::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)
+/**
+ * Process a command read from the ini file
+ *
+ * @param aCommand			The command to process
+ * @param aSection			The section in the ini containing data for the command
+ * @param aAsyncErrorIndex	Command index for async calls to return errors to
+ *
+ * @return					ETrue if the command is processed
+ *
+ * @leave					System wide error
+ */
+	{
+	TBool	ret=ETrue;
+
+	if ( aCommand==KCmdPsuInfo )
+		{
+		DoCmdPsuInfo(aSection);
+		}
+	else if ( aCommand==KCmdPsuVoltage )
+		{
+		DoCmdSetPsuVoltage(aSection);
+		}
+	else if ( aCommand==KCmdPsuNumber )
+		{
+		DoCmdPsuNumber(aSection);
+		}
+	else if ( aCommand==KCmdMediaChangeNumber )
+		{
+		DoCmdMediaChangeID(aSection);
+		}
+	else if ( aCommand==KCmdPsuCurLimit )
+		{
+		DoCmdPsuCurLimit(aSection);
+		}
+	else if ( aCommand==KCmdPbusState)
+		{
+		DoCmdPbusState(aSection);
+		}
+	else if ( aCommand==KCmdSetPsuState)
+		{
+		DoCmdSetPsuState(aSection);
+		}
+	else if ( aCommand==KCmdVccState)
+		{
+		DoCmdVccState(aSection);
+		}
+	else
+		{
+		ret=CT_MmcSDDriverData::DoCommandL(aCommand, aSection, aAsyncErrorIndex);
+		}
+	return ret;
+	}
+
+/**
+ * Psu information
+ *
+ * @param aSection			The section in the ini containing data for the command
+ *
+ * @return					void
+ *
+ * @leave					System wide error
+ */
+void CT_MMCSDPsuDriverData::DoCmdPsuInfo(const TDesC& aSection)
+	{
+ 	TInt err;
+ 	TPBusPsuInf psuInfo;
+	err = iMmcSDController->PsuInfo(psuInfo);
+		if ( err!=KErrNone )
+			{
+			ERR_PRINTF2(_L("Getting PsuInfo Error %d"), err);
+			SetError(err);
+			}
+		else
+			{
+			//Inactivity Timeout
+			INFO_PRINTF2(_L("PSU: Bus Inactivity timeout Period    = %d \n"),psuInfo.iInactivityTimeOut);
+			TInt	expectedInactivityTimeOut;
+			if(GetIntFromConfig(aSection, KInactivityTimeOut(), expectedInactivityTimeOut))
+				{
+				if(psuInfo.iInactivityTimeOut != expectedInactivityTimeOut)
+					{
+					SetBlockResult(EFail);
+					ERR_PRINTF3(_L("psuInfo.iInactivityTimeOut(%d) != expectedInactivityTimeOut(%d)"), psuInfo.iInactivityTimeOut, expectedInactivityTimeOut);
+					}
+				if(psuInfo.iInactivityTimeOut<=0 || psuInfo.iInactivityTimeOut>10)
+					{
+					ERR_PRINTF1(_L("MMC/SD: Error : Inactivity timeout is not programmed correctly. \n"));
+					ERR_PRINTF1(_L("MMC/SD: Inactivity time out depends on platform. Possible value can be (1/3/5/10) seconds \n"));
+					SetBlockResult(EFail);
+					}
+				}
+			else
+				{
+				SetBlockResult(EFail);
+				WARN_PRINTF1(_L("Inactivity timeout Value Missing From INI File"));
+				}
+			//NotLocked Timeout
+			INFO_PRINTF2(_L("PSU: Bus Not Locked Timeout Period = %d \n"),psuInfo.iNotLockedTimeOut);
+			TInt	expectedNotlockedtimeOut;
+			if(GetIntFromConfig(aSection, KNotlockedtimeOut(), expectedNotlockedtimeOut))
+				{
+				if(psuInfo.iNotLockedTimeOut != expectedNotlockedtimeOut)
+					{
+					SetBlockResult(EFail);
+					ERR_PRINTF3(_L("psuInfo.iNotLockedTimeOut(%d) != expectedNotlockedtimeOut(%d)"), psuInfo.iNotLockedTimeOut, expectedNotlockedtimeOut);
+					}
+				}
+			else
+				{
+				SetBlockResult(EFail);
+				WARN_PRINTF1(_L("NotlockedtimeOut Value Missing From INI File"));
+				}
+			//MaxCurrentInMicroAmps
+			INFO_PRINTF2(_L("PSU: MaxCurrentInMicroAmps     = %d \n"),psuInfo.iMaxCurrentInMicroAmps);
+			TInt	expectedMaxCurrentInMicroAmps;
+			if(GetIntFromConfig(aSection, KCurrent(), expectedMaxCurrentInMicroAmps))
+				{
+				if(psuInfo.iMaxCurrentInMicroAmps != expectedMaxCurrentInMicroAmps)
+					{
+					SetBlockResult(EFail);
+					ERR_PRINTF3(_L("psuInfo.iMaxCurrentInMicroAmps(%d) != expectedMaxCurrentInMicroAmps(%d)"), psuInfo.iMaxCurrentInMicroAmps, expectedMaxCurrentInMicroAmps);
+					}
+			 	}
+			else
+				{
+				SetBlockResult(EFail);
+				WARN_PRINTF1(_L("MaxCurrentInMicroAmps Value Missing From INI File"));
+				}
+			//Volatge Supported
+			INFO_PRINTF2(_L("PSU: Volatge Supported(OCR Register Format)     = 0x%08x(OCR Format) \n"),psuInfo.iVoltageSupported);
+			TUint	expectedVoltageSupported;
+			if(GetUintFromConfig(aSection, KVoltage(), expectedVoltageSupported))
+				{
+				 if(psuInfo.iVoltageSupported != expectedVoltageSupported)
+					{
+					SetBlockResult(EFail);
+					ERR_PRINTF3(_L("psuInfo.iVoltageSupported(0x%08x) != expectedVoltageSupported(0x%08x)"), psuInfo.iVoltageSupported, expectedVoltageSupported);
+					}
+				//Bit MASK (Refer OCR register format)
+				if(psuInfo.iVoltageSupported ==0)
+					{
+					ERR_PRINTF1(_L("MMC/SD: iVoltageSupported should not be zero \n"));
+					ERR_PRINTF1(_L("MMC/SD: iVoltageSupported depends on platform. Possible values(3.0/3.3) volts in OCR register format\n"));
+					SetBlockResult(EFail);
+					}
+			 	}
+			else
+				{
+				SetBlockResult(EFail);
+				WARN_PRINTF1(_L("VoltageSupported Value Missing From INI File"));
+				}
+			//Voltage Interval
+			INFO_PRINTF2(_L("PSU: Voltage Interval      = %x \n"),psuInfo.iVoltCheckInterval);
+			TUint	expectedVoltCheckInterval;
+			if(GetUintFromConfig(aSection, KVoltageinterval(), expectedVoltCheckInterval))
+				{
+				 if(psuInfo.iVoltCheckInterval != expectedVoltCheckInterval)
+					{
+					SetBlockResult(EFail);
+					ERR_PRINTF3(_L("psuInfo.iVoltCheckInterval(%d) != expectedVoltCheckInterval(%d)"), psuInfo.iVoltCheckInterval, expectedVoltCheckInterval);
+					}
+			 	}
+			else
+				{
+				SetBlockResult(EFail);
+				WARN_PRINTF1(_L("VoltCheckInterval Value Missing From INI File"));
+				}
+			//VoltCheckMethod
+			switch(psuInfo.iVoltCheckMethod)
+				{
+				case EDPsuChkComparator:
+					{
+					INFO_PRINTF1(_L("PSU VoltCheck Method  is  Comparator"));
+					break;
+					}
+				case EDPsuChkADCType:
+					{
+					INFO_PRINTF1(_L("PSU VoltCheck Method  is  ADCType"));
+					break;
+					}
+				case EDPsuChkADCType2:
+					{
+					INFO_PRINTF1(_L("PSU VoltCheck Method  is  ADCType2"));
+					break;
+					}
+			default:
+					ERR_PRINTF2(_L("PSU VoltCheck Method  is  Not Supported=%d"),psuInfo.iVoltCheckMethod);
+				}
+			TInt	expectedVoltCheckMethod;
+			if ( GetEnumFromConfig(aSection, KVoltagecheck(), iEnumTableVoltageCheckMethod, expectedVoltCheckMethod) )
+				{
+				 if(psuInfo.iVoltCheckMethod != (TUint)expectedVoltCheckMethod)
+					{
+					SetBlockResult(EFail);
+					ERR_PRINTF3(_L("psuInfo.iVoltCheckMethod(%d) != expectedVoltCheckMethod(%d)"), psuInfo.iVoltCheckMethod, expectedVoltCheckMethod);
+					}
+				}
+			else
+				{
+				SetBlockResult(EFail);
+				WARN_PRINTF1(_L("expectedVoltCheckMethod Value Missing From INI File"));
+				}
+
+			}
+	}
+
+/**
+ * TPBusState Information
+ *
+ * @param aSection			The section in the ini containing data for the command
+ *
+ * @return					void
+ *
+ * @leave					System wide error
+ */
+void CT_MMCSDPsuDriverData::DoCmdPbusState(const TDesC& aSection)
+	{
+	TInt err;
+	TInt pbusState;
+	err= iMmcSDController->PbusState(pbusState);
+		if(err != KErrNone)
+			{
+			ERR_PRINTF2(_L("MMC/SD : Error in getting PbusState information, error code = %d \n"),err);
+			SetError(err);
+			}
+		else
+			{
+			switch(pbusState)
+				{
+				case EBusCardAbsent:
+					{
+					WARN_PRINTF1(_L("Card is absent in the slot"));
+					break;
+					}
+				case EBusOff:
+					{
+					INFO_PRINTF1(_L("Bus State is OFF"));
+					break;
+					}
+				case EBusPoweringUp:
+					{
+					INFO_PRINTF1(_L("Bus State is Powerwing Up"));
+					break;
+					}
+				case EBusOn:
+					{
+					INFO_PRINTF1(_L("Bus State is Power ON"));
+					break;
+					}
+				case EBusPsuFault:
+					{
+					WARN_PRINTF1(_L("Bus State is BusPsuFault"));
+					break;
+					}
+				case EBusPowerUpPending:
+					{
+					INFO_PRINTF1(_L("Bus State is BusPowerUpPending"));
+					break;
+					}
+			default:
+					ERR_PRINTF2(_L("Bus State Not Supported = %d"),pbusState);
+				}
+			TInt	expectedPbusState;
+			if ( GetEnumFromConfig(aSection, KPbusState(), iEnumTablePbusState, expectedPbusState) )
+				{
+				if(pbusState != expectedPbusState)
+					{
+					ERR_PRINTF3(_L("pbusState(%d) != expectedPbusState(%d)"), pbusState, expectedPbusState);
+					SetBlockResult(EFail);
+					}
+				}
+			else
+				{
+				SetBlockResult(EFail);
+				WARN_PRINTF1(_L("expectedPbusState Value Missing From INI File"));
+				}
+			}
+
+	}
+
+/**
+ * Set Power Supply State
+ *
+ * @param aSection			The section in the ini containing data for the command
+ *
+ * @return					void
+ *
+ * @leave					System wide error
+ */
+void CT_MMCSDPsuDriverData::DoCmdSetPsuState(const TDesC& aSection)
+	{
+	TInt err;
+	TInt psuState;
+	GetIntFromConfig(aSection, KPsuState(), psuState);
+	err=iMmcSDController->SetPsuState(psuState);
+	if(err != KErrNone)
+		{
+		ERR_PRINTF2(_L("MMCSD : Error in Setting PowerSupply State, error code = %d \n"),err);
+		SetError(err);
+		}
+	}
+
+/**
+ * PSU VCC State Information
+ *
+ * @param aSection			The section in the ini containing data for the command
+ *
+ * @return					void
+ *
+ * @leave					System wide error
+ */
+void CT_MMCSDPsuDriverData::DoCmdVccState(const TDesC& aSection)
+	{
+	TInt err;
+	TInt vccState;
+	err= iMmcSDController->VccState(vccState);
+	if(err != KErrNone)
+			{
+			ERR_PRINTF2(_L("MMC/SD : Error in getting VccState information, error code = %d \n"),err);
+			SetBlockResult(EFail);
+			}
+		else
+			{
+			switch(vccState)
+				{
+				case EDPsuOff:
+					{
+					INFO_PRINTF1(_L("PSU VCC State  is PsuOff "));
+					break;
+					}
+				case EDPsuOnCurLimit:
+					{
+					INFO_PRINTF1(_L("PSU VCC State  is PsuOnCurLimit "));
+					break;
+					}
+				case EDPsuOnFull:
+					{
+					INFO_PRINTF1(_L("PSU VCC State  is PsuOnFull "));
+					break;
+					}
+			default:
+					ERR_PRINTF2(_L("PSU VCC State Not Supported = %d"),vccState);
+				}
+			TInt	expectedvccState;
+			if ( GetEnumFromConfig(aSection, KVccState(), iEnumTableVccState, expectedvccState) )
+				{
+				if(vccState != expectedvccState)
+					{
+					ERR_PRINTF3(_L("vccState(%d) != expectedvccState(%d)"), vccState, expectedvccState);
+					SetBlockResult(EFail);
+					}
+				}
+			else
+				{
+				SetBlockResult(EFail);
+				WARN_PRINTF1(_L("expectedvccState Value Missing From INI File"));
+				}
+			}
+	}
+/**
+ *Set Psu Voltage in OCR Format
+ *
+ * @param aSection			The section in the ini containing data for the command
+ *
+ * @return					void
+ *
+ * @leave					System wide error
+ */
+void CT_MMCSDPsuDriverData::DoCmdSetPsuVoltage(const TDesC& aSection)
+	{
+	TInt err;
+	TUint psuVoltage; //OCR Register Format
+	GetUintFromConfig(aSection, KPsuVoltage(), psuVoltage);
+	err=iMmcSDController->SetPsuVoltage(psuVoltage);
+	if(err != KErrNone)
+		{
+		ERR_PRINTF2(_L("MMCSD : Error in Setting Psu Voltage, error code = %d \n"),err);
+		SetError(err);
+		}
+	}
+
+/**
+ *Reads the MMCSD power supply unit number
+ *
+ * @param aSection			The section in the ini containing data for the command
+ *
+ * @return					void
+ *
+ * @leave					System wide error
+ */
+void CT_MMCSDPsuDriverData::DoCmdPsuNumber(const TDesC& aSection)
+	{
+	TInt err;
+	TInt psuNumber;
+	err=iMmcSDController->PsuNumber(psuNumber);
+	if(err != KErrNone)
+		{
+		ERR_PRINTF2(_L("MMCSD : Error in reading PSU Number from the platform, error code = %d \n"),err);
+		SetError(err);
+		}
+	else
+		{
+		INFO_PRINTF2(_L("MMCSD Psu Number on platform   = %d \n"),psuNumber);
+		TInt	expectedpsuNumber;
+		if(GetIntFromConfig(aSection, KExpectedpsuNumber(), expectedpsuNumber))
+			{
+			if(psuNumber != expectedpsuNumber)
+				{
+				ERR_PRINTF3(_L("psuNumber(%d) != expectedpsuNumber(%d)"), psuNumber, expectedpsuNumber);
+				SetBlockResult(EFail);
+				}
+			}
+		else
+			{
+			SetBlockResult(EFail);
+			WARN_PRINTF1(_L("expectedpsuNumber Value Missing From INI File"));
+			}
+		}
+	}
+
+/**
+ *Reads the MMCSD Media Change ID
+ *
+ * @param aSection			The section in the ini containing data for the command
+ *
+ * @return					void
+ *
+ * @leave					System wide error
+ */
+void CT_MMCSDPsuDriverData::DoCmdMediaChangeID(const TDesC& aSection)
+	{
+	TInt err;
+	TInt mediaChangeNumber;
+	err=iMmcSDController->MediaChangeID(mediaChangeNumber);
+	if(err != KErrNone)
+		{
+		ERR_PRINTF2(_L("MMCSD : Error in reading MeadiaChangeID from the platform, error code = %d \n"),err);
+		SetError(err);
+		}
+	else
+		{
+		INFO_PRINTF2(_L("MMCSD MeadiaChangeID on platform   = %d \n"),mediaChangeNumber);
+		TInt	expectedmediaChangeNumber;
+		if(GetIntFromConfig(aSection, KExpectedmediaChangeNumber(), expectedmediaChangeNumber))
+			{
+			if(mediaChangeNumber != expectedmediaChangeNumber)
+				{
+				ERR_PRINTF3(_L("mediaChangeNumber(%d) != expectedmediaChangeNumber(%d)"), mediaChangeNumber, expectedmediaChangeNumber);
+				SetBlockResult(EFail);
+				};
+			}
+		else
+			{
+			SetBlockResult(EFail);
+			WARN_PRINTF1(_L("expectedmediaChangeNumber Value Missing From INI File"));
+			}
+		}
+
+	}
+
+/**
+ *Reads PSU current is limited to a safe level or Not
+ *
+ * @param aSection			The section in the ini containing data for the command
+ *
+ * @return					void
+ *
+ * @leave					System wide error
+ */
+void CT_MMCSDPsuDriverData::DoCmdPsuCurLimit(const TDesC& aSection)
+	{
+	TInt err;
+	TBool psuCurLimit;
+	err=iMmcSDController->PsuCurLimit(psuCurLimit);
+	if(err != KErrNone)
+		{
+		ERR_PRINTF2(_L("MMCSD : Error in reading PsuCurLimit from the platform, error code = %d \n"),err);
+		SetError(err);
+		}
+	else
+		{
+		INFO_PRINTF2(_L("MMCSD PsuCurLimit on platform   = %d \n"),psuCurLimit);
+		TInt	expectedpsuCurLimit;
+		if(GetIntFromConfig(aSection, KExpectedpsuCurLimit(), expectedpsuCurLimit))
+			{
+			if(psuCurLimit != expectedpsuCurLimit)
+				{
+				ERR_PRINTF3(_L("psuCurLimit(%d) != expectedpsuCurLimit(%d)"), psuCurLimit, expectedpsuCurLimit);
+				SetBlockResult(EFail);
+				}
+			}
+		else
+			{
+			SetBlockResult(EFail);
+			WARN_PRINTF1(_L("expectedpsuCurLimit Value Missing From INI File"));
+			}
+		}
+	}