/*
* 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))
{
if(memVoltageSupported != expectedmemVoltageSupported)
{
SetBlockResult(EFail);
ERR_PRINTF3(_L("memVoltageSupported(%x) != expectedmemVoltageSupported(%x)"), memVoltageSupported, expectedmemVoltageSupported);
}
}
else
{
SetBlockResult(EFail);
WARN_PRINTF1(_L("expectedmemVoltageSupported Value Missing From INI File"));
}
}
}
/**
* 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::DoCmdMemMaxCurrentInMicroAmps(const TDesC& aSection)
{
TInt err;
TInt memMaxCurrentInMicroAmps;
err = iMmcSDController->MemMaxCurrentInMicroAmps(memMaxCurrentInMicroAmps);
if ( err!=KErrNone )
{
ERR_PRINTF2(_L("MemMaxCurrentInMicroAmps Error %d"), err);
SetError(err);
}
else
{
//MemMaxCurrentInMicroAmps
INFO_PRINTF2(_L("PSUBASE: MemMaxCurrentInMicroAmps = %d \n"),memMaxCurrentInMicroAmps);
TInt expectedmemMaxCurrentInMicroAmps;
if(GetIntFromConfig(aSection, KExpectedMemMaxCurrentInMicroAmps(), expectedmemMaxCurrentInMicroAmps))
{
if(memMaxCurrentInMicroAmps != expectedmemMaxCurrentInMicroAmps)
{
SetBlockResult(EFail);
ERR_PRINTF3(_L("memMaxCurrentInMicroAmps(%d) != expectedmemMaxCurrentInMicroAmps(%d)"), memMaxCurrentInMicroAmps, expectedmemMaxCurrentInMicroAmps);
}
}
else
{
SetBlockResult(EFail);
WARN_PRINTF1(_L("expectedmemMaxCurrentInMicroAmps Value Missing From INI File"));
}
}
}
/**
* Indicates whether the platform hardware has support for checking whether the voltage level of the
* PSU is within its expected voltage limit while turned on
*
* @param aSection The section in the ini containing data for the command
*
* @return void
*
* @leave System wide error
*/
void CT_MMCSDPsuBaseDriverData::DoCmdVoltCheckInterval(const TDesC& aSection)
{
TInt err;
TUint voltCheckInterval;
err = iMmcSDController->VoltCheckInterval(voltCheckInterval);
if ( err!=KErrNone )
{
ERR_PRINTF2(_L("VoltCheckInterval Error %d"), err);
SetError(err);
}
else
{
//VoltCheckInterval
INFO_PRINTF2(_L("PSUBASE: VoltCheckInterval = %u \n"),voltCheckInterval);
TUint expectedvoltCheckInterval;
if(GetUintFromConfig(aSection, KExpectedVoltageinterval(), expectedvoltCheckInterval))
{
if(voltCheckInterval != expectedvoltCheckInterval)
{
SetBlockResult(EFail);
ERR_PRINTF3(_L("voltCheckInterval(%u) != expectedvoltCheckInterval(%u)"), voltCheckInterval, expectedvoltCheckInterval);
}
}
else
{
SetBlockResult(EFail);
WARN_PRINTF1(_L("expectedvoltCheckInterval Value Missing From INI File"));
}
}
}