/*

* 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_MmcSDPsuBaseDriverData.h"

//MMCSD Commands index

/*@{*/

_LIT(KCmdIsLocked,							"IsLocked");

_LIT(KCmdIsOff,								"IsOff");

_LIT(KCmdMaxCurrentInMicroAmps,				"MaxCurrentInMicroAmps");

_LIT(KCmdResetInactivityTimer,				"ResetInactivityTimer");

_LIT(KCmdVoltageSupported,					"VoltageSupported");

_LIT(KCmdInactivityCount,					"InactivityCount");

_LIT(KCmdNotLockedCount,					"NotLockedCount");

_LIT(KCmdInactivityTimeout,					"InactivityTimeout");

_LIT(KCmdNotLockedTimeout,					"NotLockedTimeout");

_LIT(KCmdMemVoltageSupported,				"MemVoltageSupported");

_LIT(KCmdMemMaxCurrentInMicroAmps,			"MemMaxCurrentInMicroAmps");

_LIT(KCmdVoltCheckInterval,					"VoltCheckInterval");

_LIT(KExpectedLockState,					"expectedlockstate");

_LIT(KExpectedPsuState,						"expectedpsustate");

_LIT(KExpectedCurrent,						"expectedcurrent");

_LIT(KExpectedVoltage,						"expectedvoltage");

_LIT(KExpectedInactivityCount,				"expectedinactivityCount");

_LIT(KExpectedNotLockedCount,				"expectednotLockedCount");

_LIT(KExpectedInactivityTimeout,			"expectedinactivityTimeout");

_LIT(KExpectedNotLockedTimeout,				"expectednotlockedtimeOut");

_LIT(KExpectedMemVoltageSupported,			"expectedmemVoltageSupported");

_LIT(KExpectedMemMaxCurrentInMicroAmps,		"expectedmemMaxCurrentInMicroAmps");

_LIT(KExpectedVoltageinterval,				"expectedvoltageinterval");

/*@}*/

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

CT_MMCSDPsuBaseDriverData* CT_MMCSDPsuBaseDriverData::NewL()

	{

	CT_MMCSDPsuBaseDriverData*	ret=new (ELeave) CT_MMCSDPsuBaseDriverData();

	CleanupStack::PushL(ret);

	ret->ConstructL();

	CleanupStack::Pop(ret);

	return ret;

	}

CT_MMCSDPsuBaseDriverData::CT_MMCSDPsuBaseDriverData()

:	CT_MmcSDDriverData()

,	iAsyncErrorIndex(0)

	{

	}

void CT_MMCSDPsuBaseDriverData::ConstructL()

/**

 * Second phase construction

 *

 * @internalComponent

 *

 * @return	N/A

 *

 * @pre		None

 * @post	None

 *

 * @leave	system wide error

 */

	{

	CT_MmcSDDriverData::ConstructL();

	}

CT_MMCSDPsuBaseDriverData::~CT_MMCSDPsuBaseDriverData()

/**

 * Public destructor

 */

	{

	}

TBool CT_MMCSDPsuBaseDriverData::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==KCmdIsLocked )

		{

		DoCmdIsLocked(aSection);

		}

	else if ( aCommand==KCmdIsOff )

		{

		DoCmdIsOff(aSection);

		}

	else if ( aCommand==KCmdMaxCurrentInMicroAmps )

		{

		DoCmdMaxCurrentInMicroAmps(aSection);

		}

	else if ( aCommand==KCmdResetInactivityTimer )

		{

		DoCmdResetInactivityTimer();

		}

	else if ( aCommand==KCmdVoltageSupported)

		{

		DoCmdVoltageSupported(aSection);

		}

	else if ( aCommand==KCmdInactivityCount)

		{

		DoCmdInactivityCount(aSection);

		}

	else if ( aCommand==KCmdNotLockedCount)

		{

		DoCmdNotLockedCount(aSection);

		}

	else if ( aCommand==KCmdInactivityTimeout)

		{

		DoCmdInactivityTimeout(aSection);

		}

	else if ( aCommand==KCmdNotLockedTimeout)

		{

		DoCmdNotLockedTimeout(aSection);

		}

	else if ( aCommand==KCmdMemVoltageSupported)

		{

		DoCmdMemVoltageSupported(aSection);

		}

	else if ( aCommand==KCmdMemMaxCurrentInMicroAmps)

		{

		DoCmdMemMaxCurrentInMicroAmps(aSection);

		}

	else if ( aCommand==KCmdVoltCheckInterval)

		{

		DoCmdVoltCheckInterval(aSection);

		}

	else

		{

		ret=CT_MmcSDDriverData::DoCommandL(aCommand, aSection, aAsyncErrorIndex);

		}

	return ret;

	}

/**

 * Checks whether this PSU is powering a bus containing a locked device

 * i.e. one that is recognised and in use by a client

 *

 * @param aSection			The section in the ini containing data for the command

 *

 * @return					void

 *

 * @leave					System wide error

 */

void CT_MMCSDPsuBaseDriverData::DoCmdIsLocked(const TDesC& aSection)

	{

 	TInt err;

 	TBool lockstate;

 	err = iMmcSDController->IsLocked(lockstate);

	if ( err!=KErrNone )

		{

		ERR_PRINTF2(_L("Getting Lock Information Error %d"), err);

		SetError(err);

		}

	else

		{

		//IsLocked?

		INFO_PRINTF2(_L("PSUBASE: IsLocked    = %d \n"),lockstate);

		TBool	expectedlockstate;

		if(GetBoolFromConfig(aSection, KExpectedLockState(), expectedlockstate))

			{

			if(lockstate != expectedlockstate)

				{

				SetBlockResult(EFail);

				ERR_PRINTF3(_L("lockstate(%d) != expectedlockstate(%d)"), lockstate, expectedlockstate);

				}

			}

		else

			{

			SetBlockResult(EFail);

			WARN_PRINTF1(_L("expectedlockstate Value Missing From INI File"));

			}

		}

	}

/**

 * Checks whether the PSU is off

 *

 * @param aSection			The section in the ini containing data for the command

 *

 * @return					void

 *

 * @leave					System wide error

 */

void CT_MMCSDPsuBaseDriverData::DoCmdIsOff(const TDesC& aSection)

	{

 	TInt err;

 	TBool psustate;

 	err = iMmcSDController->IsOff(psustate);

	if ( err!=KErrNone )

		{

		ERR_PRINTF2(_L("Getting PSU State Information Error %d"), err);

		SetError(err);

		}

	else

		{

		//IsLocked?

		INFO_PRINTF2(_L("PSUBASE: IsOff    = %d \n"),psustate);

		TBool	expectedpsustate;

		if(GetBoolFromConfig(aSection, KExpectedPsuState(), expectedpsustate))

			{

			if(psustate != expectedpsustate)

				{

				SetBlockResult(EFail);

				ERR_PRINTF3(_L("psustate(%d) != expectedpsustate(%d)"), psustate, expectedpsustate);

				}

			}

		else

			{

			SetBlockResult(EFail);

			WARN_PRINTF1(_L("expectedpsustate Value Missing From INI File"));

			}

		}

	}

/**

 * Gets the maximum current (in microAmps) that the PSU is able to supply

 *

 * @param aSection			The section in the ini containing data for the command

 *

 * @return					void

 *

 * @leave					System wide error

 */

void CT_MMCSDPsuBaseDriverData::DoCmdMaxCurrentInMicroAmps(const TDesC& aSection)

	{

 	TInt err;

 	TInt current;

 	err = iMmcSDController->MaxCurrentInMicroAmps(current);

	if ( err!=KErrNone )

		{

		ERR_PRINTF2(_L("Getting MaxCurrentInMicroAmps Error %d"), err);

		SetError(err);

		}

	else

		{

		//MaxCurrentInMicroAmps

		INFO_PRINTF2(_L("PSUBASE: MaxCurrentInMicroAmps   = %d \n"),current);

		TInt	expectedcurrent;

		if(GetIntFromConfig(aSection, KExpectedCurrent(), expectedcurrent))

			{

			if(current != expectedcurrent)

				{

				SetBlockResult(EFail);

				ERR_PRINTF3(_L("current(%d) != expectedcurrent(%d)"), current, expectedcurrent);

				}

			}

		else

			{

			SetBlockResult(EFail);

			WARN_PRINTF1(_L("expectedcurrent Value Missing From INI File"));

			}

		}

	}

/**

 * Resets inactivity and not-locked counts

 *

 * @return					void

 *

 * @leave					System wide error

 */

void CT_MMCSDPsuBaseDriverData::DoCmdResetInactivityTimer()

	{

 	TInt err;

 	err = iMmcSDController->ResetInactivityTimer();

	if ( err!=KErrNone )

		{

		ERR_PRINTF2(_L("ResetInactivityTimer Error %d"), err);

		SetError(err);

		}

	}

/**

 * Gets the voltage level, or range of supported voltage levels

 *

 * @param aSection			The section in the ini containing data for the command

 *

 * @return					void

 *

 * @leave					System wide error

 */

void CT_MMCSDPsuBaseDriverData::DoCmdVoltageSupported(const TDesC& aSection)

	{

 	TInt err;

 	TUint volt;

 	err = iMmcSDController->VoltageSupported(volt);

	if ( err!=KErrNone )

		{

		ERR_PRINTF2(_L("VoltageSupported Error %d"), err);

		SetError(err);

		}

	else

		{

		//VoltageSupported

		INFO_PRINTF2(_L("PSUBASE: VoltageSupported  = %x \n"),volt);

		TUint	expectedvolt;

		if(GetUintFromConfig(aSection, KExpectedVoltage(), expectedvolt))

			{

			if(volt != expectedvolt)

				{

				SetBlockResult(EFail);

				ERR_PRINTF3(_L("volt(%x) != expectedvolt(%x)"), volt, expectedvolt);

				}

			}

		else

			{

			SetBlockResult(EFail);

			WARN_PRINTF1(_L("expectedvolt Value Missing From INI File"));

			}

		}

	}

/**

 * Bus inactivity counter

 *

 * @param aSection			The section in the ini containing data for the command

 *

 * @return					void

 *

 * @leave					System wide error

 */

void CT_MMCSDPsuBaseDriverData::DoCmdInactivityCount(const TDesC& aSection)

	{

 	TInt err;

 	TInt inactivityCount;

 	err = iMmcSDController->InactivityCount(inactivityCount);

	if ( err!=KErrNone )

		{

		ERR_PRINTF2(_L("InactivityCount Error %d"), err);

		SetError(err);

		}

	else

		{

		//InactivityCount

		INFO_PRINTF2(_L("PSUBASE: InactivityCount  = %d \n"),inactivityCount);

		TInt	expectedinactivityCount;

		if(GetIntFromConfig(aSection, KExpectedInactivityCount(), expectedinactivityCount))

			{

			if(inactivityCount != expectedinactivityCount)

				{

				SetBlockResult(EFail);

				ERR_PRINTF3(_L("inactivityCount(%d) != expectedinactivityCount(%d)"), inactivityCount, expectedinactivityCount);

				}

			}

		else

			{

			SetBlockResult(EFail);

			WARN_PRINTF1(_L("expectedinactivityCount Value Missing From INI File"));

			}

		}

	}

/**

 * Bus not locked counter

 *

 * @param aSection			The section in the ini containing data for the command

 *

 * @return					void

 *

 * @leave					System wide error

 */

void CT_MMCSDPsuBaseDriverData::DoCmdNotLockedCount(const TDesC& aSection)

	{

 	TInt err;

 	TInt notLockedCount;

 	err = iMmcSDController->NotLockedCount(notLockedCount);

	if ( err!=KErrNone )

		{

		ERR_PRINTF2(_L("NotLockedCount Error %d"), err);

		SetError(err);

		}

	else

		{

		//NotLockedCount

		INFO_PRINTF2(_L("PSUBASE: NotLockedCount  = %d \n"),notLockedCount);

		TInt	expectednotLockedCount;

		if(GetIntFromConfig(aSection, KExpectedNotLockedCount(), expectednotLockedCount))

			{

			if(notLockedCount != expectednotLockedCount)

				{

				SetBlockResult(EFail);

				ERR_PRINTF3(_L("notLockedCount(%d) != expectednotLockedCount(%d)"), notLockedCount, expectednotLockedCount);

				}

			}

		else

			{

			SetBlockResult(EFail);

			WARN_PRINTF1(_L("expectednotLockedCount Value Missing From INI File"));

			}

		}

	}

/**

 * Bus inactivity timeout period, in seconds, when clients are registered

 *

 * @param aSection			The section in the ini containing data for the command

 *

 * @return					void

 *

 * @leave					System wide error

 */

void CT_MMCSDPsuBaseDriverData::DoCmdInactivityTimeout(const TDesC& aSection)

	{

 	TInt err;

 	TInt inactivityTimeout;

 	err = iMmcSDController->InactivityTimeout(inactivityTimeout);

	if ( err!=KErrNone )

		{

		ERR_PRINTF2(_L("InactivityTimeout Error %d"), err);

		SetError(err);

		}

	else

		{

		//InactivityTimeout

		INFO_PRINTF2(_L("PSUBASE: InactivityTimeout  = %d \n"),inactivityTimeout);

		TInt	expectedinactivityTimeout;

		if(GetIntFromConfig(aSection, KExpectedInactivityTimeout(), expectedinactivityTimeout))

			{

			if(inactivityTimeout != expectedinactivityTimeout)

				{

				SetBlockResult(EFail);

				ERR_PRINTF3(_L("inactivityTimeout(%d) != expectedinactivityTimeout(%d)"), inactivityTimeout, expectedinactivityTimeout);

				}

			}

		else

			{

			SetBlockResult(EFail);

			WARN_PRINTF1(_L("expectedinactivityTimeout Value Missing From INI File"));

			}

		}

	}

/**

 * Bus not locked timeout period, in seconds, when no clients are registered

 *

 * @param aSection			The section in the ini containing data for the command

 *

 * @return					void

 *

 * @leave					System wide error

 */

void CT_MMCSDPsuBaseDriverData::DoCmdNotLockedTimeout(const TDesC& aSection)

	{

 	TInt err;

 	TInt notLockedTimeout;

 	err = iMmcSDController->NotLockedTimeout(notLockedTimeout);

	if ( err!=KErrNone )

		{

		ERR_PRINTF2(_L("NotLockedTimeout Error %d"), err);

		SetError(err);

		}

	else

		{

		//NotLockedTimeout

		INFO_PRINTF2(_L("PSUBASE: NotLockedTimeout  = %d \n"),notLockedTimeout);

		TInt	expectednotLockedTimeout;

		if(GetIntFromConfig(aSection, KExpectedNotLockedTimeout(), expectednotLockedTimeout))

			{

			if(notLockedTimeout != expectednotLockedTimeout)

				{

				SetBlockResult(EFail);

				ERR_PRINTF3(_L("notLockedTimeout(%d) != expectednotLockedTimeout(%d)"), notLockedTimeout, expectednotLockedTimeout);

				}

			}

		else

			{

			SetBlockResult(EFail);

			WARN_PRINTF1(_L("expectednotLockedTimeout Value Missing From INI File"));

			}

		}

	}

/**

 * Indicates the voltage level, or range of voltages supported

 *

 * @param aSection			The section in the ini containing data for the command

 *

 * @return					void

 *

 * @leave					System wide error

 */

void CT_MMCSDPsuBaseDriverData::DoCmdMemVoltageSupported(const TDesC& aSection)

	{

 	TInt err;

 	TUint memVoltageSupported;

 	err = iMmcSDController->MemVoltageSupported(memVoltageSupported);

	if ( err!=KErrNone )

		{

		ERR_PRINTF2(_L("MemVoltageSupported Error %u"), err);

		SetError(err);

		}

	else

		{

		//MemVoltageSupported

		INFO_PRINTF2(_L("PSUBASE: MemVoltageSupported  = %x \n"),memVoltageSupported);

		TUint	expectedmemVoltageSupported;

		if(GetUintFromConfig(aSection, KExpectedMemVoltageSupported(), expectedmemVoltageSupported))

			{