/*

* 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

 */