/*

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

 #include "T_TCommCapsV01Data.h"

 #include "T_TCommConfigV01Data.h"

 /*@{*/

 _LIT(KStrNull,								" ");

 _LIT(KCmdConstructor,						"new");

 _LIT(KCmdDestructor,						"~");

 _LIT(KCmdBreak,								"Break");

 _LIT(KCmdBreakCancel,						"BreakCancel");

 _LIT(KCmdCaps,								"Caps");

 _LIT(KCmdConfig,							"Config");

 _LIT(KCmdMinTurnaroundTime,					"MinTurnaroundTime");

 _LIT(KCmdNotifyReceiveDataAvailable,		"NotifyReceiveDataAvailable");

 _LIT(KCmdNotifyReceiveDataAvailableCancel,	"NotifyReceiveDataAvailableCancel");

 _LIT(KCmdNotifySignalChange,				"NotifySignalChange");

 _LIT(KCmdNotifySignalChangeCancel,			"NotifySignalChangeCancel");

 _LIT(KCmdOpen,								"Open");

 _LIT(KCmdQueryReceiveBuffer,				"QueryReceiveBuffer");

 _LIT(KCmdRead,								"Read");

 _LIT(KCmdReadCancel,						"ReadCancel");

 _LIT(KCmdReadOneOrMore,						"ReadOneOrMore");

 _LIT(KCmdReceiveBufferLength,				"ReceiveBufferLength");

 _LIT(KCmdResetBuffers,						"ResetBuffers");

 _LIT(KCmdSetConfig,							"SetConfig");

 _LIT(KCmdSetMinTurnaroundTime,				"SetMinTurnaroundTime");

 _LIT(KCmdSetReceiveBufferLength,			"SetReceiveBufferLength");

 _LIT(KCmdSetSignals,						"SetSignals");

 _LIT(KCmdSignals,							"Signals");

 _LIT(KCmdVersionRequired,					"VersionRequired");

 _LIT(KCmdWrite,								"Write");

 _LIT(KCmdWriteCancel,						"WriteCancel");

 _LIT(KFldBufferLength,						"bufferlength");

 _LIT(KFldCaps,								"caps");

 _LIT(KFldClearMask,							"clearmask");

 _LIT(KFldConfig,							"config");

 _LIT(KFldData,								"data");

 _LIT(KFldExpected,							"expected");

 _LIT(KFldExpectedFile,						"expected_file");

 _LIT(KFldFile,								"file");

 _LIT(KFldIsEmpty,							"is_empty");

 _LIT(KFldMask,								"mask");

 _LIT(KFldPortPDD,							"portpdd");

 _LIT(KFldPortLDD,							"portldd");

 _LIT(KFldRepeat,							"repeat");

 _LIT(KFldSave,								"save");

 _LIT(KFldSetMask,							"setmask");

 _LIT(KFldTime,								"time");

 _LIT(KFldTimeOut,							"timeout");

 _LIT(KFldUnit,								"unit");

 _LIT(KFldUseLength,							"uselength");

 _LIT(KFldValue,								"value");

 _LIT(KFldVersionName,						"version_name");

 _LIT(KFldVersionBuild,						"version_build");

 _LIT(KFldVersionMajor,						"version_major");

 _LIT(KFldVersionMinor,						"version_minor");

 _LIT(KLogError,								"Error=%d");

 _LIT(KLogErrorBufferLength,					"Buffer Length %d must be greater than 0");

 _LIT(KLogErrorExpectedValue,				"Expected Value does not match actual");

 _LIT(KLogErrorExpectedSignal,				"Expected Signal %d does not match actual %d");

 _LIT(KLogMissingParameter,					"Missing parameter '%S'");

 _LIT(KLogNullCapsData,						"Caps Data - '%S' is NULL");

 _LIT(KLogNullConfigData,					"Config Data - '%S' is NULL");

 _LIT(KLogLoadPhysicalDeviceError,			"Load Physical Device '%S' error=%d");

 _LIT(KLogLoadLogicalDeviceError,			"Load Logical Device '%S' error=%d");

 /*@}*/

 _LIT(KStrKSignalCTS,						"KSignalCTS");

 _LIT(KStrKSignalDSR,						"KSignalDSR");

 _LIT(KStrKSignalDCD,						"KSignalDCD");

 _LIT(KStrKSignalRNG,						"KSignalRNG");

 _LIT(KStrKSignalRTS,						"KSignalRTS");

 _LIT(KStrKSignalDTR,						"KSignalDTR");

 _LIT(KStrKSignalBreak,						"KSignalBreak");

 const CDataWrapperBase::TEnumEntryTable	CT_RBusDevCommData::iEnumTableSignals[] =

 	{

 //	Enum as a descriptor					Enum

 	KStrKSignalCTS,							KSignalCTS,

 	KStrKSignalDSR,							KSignalDSR,

 	KStrKSignalDCD,							KSignalDCD,

 	KStrKSignalRNG,							KSignalRNG,

 	KStrKSignalRTS,							KSignalRTS,

 	KStrKSignalDTR,							KSignalDTR,

 	KStrKSignalBreak,						KSignalBreak,

 	KStrNull,								-1

 	};

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

 // Construction/Destruction

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

 CT_RBusDevCommData* CT_RBusDevCommData::NewL()

 	{

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

 	CleanupStack::PushL(ret);

 	ret->ConstructL();

 	CleanupStack::Pop(ret);

 	return ret;

 	}

 CT_RBusDevCommData::CT_RBusDevCommData()

 :	CT_RBusLogicalChannelData()

 ,	iBusDevComm(NULL)

 ,	iBufferRead(NULL)

 ,	iBufferReadPtr(NULL, 0)

 ,	iBufferReadOneOrMorePtr(NULL, 0)

 ,	iReadOneOrMoreLeft(0)

 ,	iHasReadExpected(EFalse)

 ,	iBufferLength(0)

 ,	iMinTurnaroundTime(0)

 ,	iReceiveBufferLength(0)

 ,	iSignals(0)

 ,	iNotifySignals(0)

 ,	iHasNotifySignalsExpected(EFalse)

 ,	iNotifySignalsExpected(0)

 ,	iCallbackBreak(NULL)

 ,	iCallbackNotifyReceiveDataAvailable(NULL)

 ,	iCallbackNotifySignalChange(NULL)

 ,	iCallbackRead(NULL)

 ,	iCallbackReadOneOrMore(NULL)

 ,	iCallbackWrite(NULL)

 	{

 	}

 CT_RBusDevCommData::~CT_RBusDevCommData()

 /**

  * Public destructor

  */

 	{

 	DestroyData();

 	delete iBufferRead;

 	iBufferRead=NULL;

 	delete iCallbackWrite;

 	iCallbackWrite=NULL;

 	delete iCallbackReadOneOrMore;

 	iCallbackReadOneOrMore=NULL;

 	delete iCallbackRead;

 	iCallbackRead=NULL;

 	delete iCallbackNotifySignalChange;

 	iCallbackNotifySignalChange=NULL;

 	delete iCallbackNotifyReceiveDataAvailable;

 	iCallbackNotifyReceiveDataAvailable=NULL;

 	delete iCallbackBreak;

 	iCallbackBreak=NULL;

 	}

 void CT_RBusDevCommData::ConstructL()

 	{

 	iCallbackBreak						=CActiveCallbackBase::NewL(*this);

 	iCallbackNotifyReceiveDataAvailable	=CActiveCallbackBase::NewL(*this);

 	iCallbackNotifySignalChange			=CActiveCallbackBase::NewL(*this);

 	iCallbackRead						=CT_ActiveCallbackIO::NewL(*this);

 	iCallbackReadOneOrMore				=CT_ActiveCallbackIO::NewL(*this);

 	iCallbackWrite						=CT_ActiveCallbackIO::NewL(*this);

 	}

 void CT_RBusDevCommData::DestroyData()

 	{

 	delete iBusDevComm;

 	iBusDevComm=NULL;

 	}

 TAny* CT_RBusDevCommData::GetObject()

 /**

  * Return a pointer to the object that the data wraps

  *

  * @return	pointer to the object that the data wraps

  */

 	{

 	return iBusDevComm;

 	}

 RHandleBase* CT_RBusDevCommData::GetHandleBase()

 	{

 	return iBusDevComm;

 	}

 RBusLogicalChannel* CT_RBusDevCommData::GetBusLogicalChannel()

 	{

 	return iBusDevComm;

 	}

 void CT_RBusDevCommData::PrepareReadExpectedBufferLengthL(CT_ActiveCallbackIO& aCallback, const TDesC& aSection)

 	{

 	TInt	repeat=1;

 	GetIntFromConfig(aSection, KFldRepeat, repeat);

 	TPtrC	readExpected;

 	iHasReadExpected=GetStringFromConfig(aSection, KFldExpected, readExpected);

 	if ( iHasReadExpected )

 		{

 		aCallback.PrepareFromStringL(repeat, readExpected);

 		iBufferLength=aCallback.BufferLength();

 		}

 	else

 		{

 		iHasReadExpected=GetStringFromConfig(aSection, KFldExpectedFile, readExpected);

 		if ( iHasReadExpected )

 			{

 			aCallback.PrepareFromFileL(repeat, readExpected);

 			}

 		}

 	if ( iHasReadExpected )

 		{

 		iBufferLength=aCallback.BufferLength();

 		}

 	GetIntFromConfig(aSection, KFldBufferLength, iBufferLength);

 	if ( iBufferLength <= 0 )

 		{

 		ERR_PRINTF2(KLogErrorBufferLength, iBufferLength);

 		SetBlockResult(EFail);

 		}

 	}

 TBool CT_RBusDevCommData::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;

 	TInt	err=KErrNone;

 	if ( aCommand==KCmdConstructor )

 		{

 		err=DoCmdConstructor();

 		}

 	else if ( aCommand==KCmdDestructor )

 		{

 		DoCmdDestructor();

 		}

 	else if ( aCommand==KCmdBreak )

 		{

 		DoCmdBreak(aSection, aAsyncErrorIndex);

 		}

 	else if ( aCommand==KCmdBreakCancel )

 		{

 		DoCmdBreakCancel();

 		}

 	else if ( aCommand==KCmdCaps )

 		{

 		DoCmdCapsL(aSection);

 		}

 	else if ( aCommand==KCmdConfig )

 		{

 		DoCmdConfigL(aSection);

 		}

 	else if ( aCommand==KCmdMinTurnaroundTime )

 		{

 		DoCmdMinTurnaroundTime(aSection);

 		}

 	else if ( aCommand==KCmdNotifyReceiveDataAvailable )

 		{

 		DoCmdNotifyReceiveDataAvailable(aSection, aAsyncErrorIndex);

 		}

 	else if ( aCommand==KCmdNotifyReceiveDataAvailableCancel )

 		{

 		DoCmdNotifyReceiveDataAvailableCancel();

 		}

 	else if ( aCommand==KCmdNotifySignalChange )

 		{

 		DoCmdNotifySignalChange(aSection, aAsyncErrorIndex);

 		}

 	else if ( aCommand==KCmdNotifySignalChangeCancel )

 		{

 		DoCmdNotifySignalChangeCancel();

 		}

 	else if ( aCommand==KCmdOpen )

 		{

 		err=DoCmdOpen(aSection);

 		}

 	else if ( aCommand==KCmdQueryReceiveBuffer )

 		{

 		err=DoCmdQueryReceiveBuffer(aSection);

 		}

 	else if ( aCommand==KCmdRead )

 		{

 		DoCmdReadL(aSection, aAsyncErrorIndex);

 		}

 	else if ( aCommand==KCmdReadCancel )

 		{

 		DoCmdReadCancel();

 		}

 	else if ( aCommand==KCmdReadOneOrMore )

 		{

 		DoCmdReadOneOrMoreL(aSection, aAsyncErrorIndex);

 		}

 	else if ( aCommand==KCmdReceiveBufferLength )

 		{

 		DoCmdReceiveBufferLength(aSection);

 		}

 	else if ( aCommand==KCmdResetBuffers )

 		{

 		DoCmdResetBuffers();

 		}

 	else if ( aCommand==KCmdSetConfig )

 		{

 		err=DoCmdSetConfigL(aSection);

 		}

 	else if ( aCommand==KCmdSetMinTurnaroundTime )

 		{

 		err=DoCmdSetMinTurnaroundTime(aSection);

 		}

 	else if ( aCommand==KCmdSetReceiveBufferLength )

 		{

 		err=DoCmdSetReceiveBufferLength(aSection);

 		}

 	else if ( aCommand==KCmdSetSignals )

 		{

 		DoCmdSetSignals(aSection);

 		}

 	else if ( aCommand==KCmdSignals )

 		{

 		DoCmdSignals(aSection);

 		}

 	else if ( aCommand==KCmdVersionRequired )

 		{

 		DoCmdVersionRequired(aSection);

 		}

 	else if ( aCommand==KCmdWrite )

 		{

 		DoCmdWriteL(aSection, aAsyncErrorIndex);

 		}

 	else if ( aCommand==KCmdWriteCancel )

 		{

 		DoCmdWriteCancel();

 		}

 	else

 		{

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

 		}

 	if ( err!=KErrNone )

 		{

 		ERR_PRINTF2(KLogError, err);

 		SetError(err);

 		}

 	return ret;

 	}

 TInt CT_RBusDevCommData::DoCmdConstructor()

 	{

 	DestroyData();

 	TRAPD(err, iBusDevComm=new (ELeave) RBusDevComm());

 	return err;

 	}

 void CT_RBusDevCommData::DoCmdDestructor()

 	{

 	DestroyData();

 	}

 void CT_RBusDevCommData::DoCmdBreak(const TDesC& aSection, const TInt aAsyncErrorIndex)

 	{

 	TInt	timeOut=0;

 	GetIntFromConfig(aSection, KFldTimeOut, timeOut);

 	TInt	time;

 	if ( !GetIntFromConfig(aSection, KFldTime, time) )

 		{

 		ERR_PRINTF2(KLogMissingParameter, &KFldTime());

 		SetBlockResult(EFail);

 		}

 	else

 		{

 		INFO_PRINTF1(_L("Break"));

 		iBusDevComm->Break(iCallbackBreak->iStatus, time);

 		iCallbackBreak->Activate(aAsyncErrorIndex, timeOut);

 		IncOutstanding();

 		}

 	}

 void CT_RBusDevCommData::DoCmdBreakCancel()

 	{

 	INFO_PRINTF1(_L("BreakCancel"));

 	iBusDevComm->BreakCancel();

 	}

 void CT_RBusDevCommData::DoCmdCapsL(const TDesC& aSection)

 	{

 	TPtrC	dataName;

 	if ( GetStringFromConfig(aSection, KFldCaps, dataName) )

 		{

 		CT_TCommCapsV01Data*	wrapper=static_cast<CT_TCommCapsV01Data*>(GetDataWrapperL(dataName));

 		TDes8*					data=wrapper->Descriptor();

 		if ( data!=NULL )

 			{

 			INFO_PRINTF1(_L("Caps"));

 			iBusDevComm->Caps(*data);

 			}

 		else

 			{

 			ERR_PRINTF2(KLogNullCapsData, &dataName);

 			SetBlockResult(EFail);

 			}

 		}

 	else

 		{

 		ERR_PRINTF2(KLogMissingParameter, &KFldCaps());

 		SetBlockResult(EFail);

 		}

 	}

 void CT_RBusDevCommData::DoCmdConfigL(const TDesC& aSection)

 	{

 	TPtrC	dataName;

 	if ( GetStringFromConfig(aSection, KFldConfig, dataName) )

 		{

 		CT_TCommConfigV01Data*	wrapper=static_cast<CT_TCommConfigV01Data*>(GetDataWrapperL(dataName));

 		TDes8*					data=wrapper->Descriptor();

 		if ( data!=NULL )

 			{

 			INFO_PRINTF1(_L("Config"));

 			iBusDevComm->Config(*data);

 			}

 		else

 			{

 			ERR_PRINTF2(KLogNullConfigData, &dataName);

 			SetBlockResult(EFail);

 			}

 		}

 	else

 		{

 		ERR_PRINTF2(KLogMissingParameter, &KFldConfig());

 		SetBlockResult(EFail);

 		}

 	}

 void CT_RBusDevCommData::DoCmdMinTurnaroundTime(const TDesC& aSection)

 	{

 	TUint	actual=iBusDevComm->MinTurnaroundTime();

 	INFO_PRINTF2(_L("MinTurnaroundTime : %d"), actual);

 	TUint	expected;

 	if ( GetUintFromConfig(aSection, KFldExpected(), expected) )

 		{

 		if ( expected!=actual )

 			{

 			ERR_PRINTF1(KLogErrorExpectedValue);

 			SetBlockResult(EFail);

 			}

 		}

 	TBool	save=EFalse;

 	GetBoolFromConfig(aSection, KFldSave(), save);

 	if ( save )

 		{

 		iMinTurnaroundTime=actual;

 		}

 	}

 void CT_RBusDevCommData::DoCmdNotifyReceiveDataAvailable(const TDesC& aSection, const TInt aAsyncErrorIndex)

 	{

 	TInt	timeOut=0;

 	GetIntFromConfig(aSection, KFldTimeOut, timeOut);

 	INFO_PRINTF1(_L("NotifyReceiveDataAvailable"));

 	iBusDevComm->NotifyReceiveDataAvailable(iCallbackNotifyReceiveDataAvailable->iStatus);

 	iCallbackNotifyReceiveDataAvailable->Activate(aAsyncErrorIndex, timeOut);

 	IncOutstanding();

 	}

 void CT_RBusDevCommData::DoCmdNotifyReceiveDataAvailableCancel()

 	{

 	INFO_PRINTF1(_L("NotifyReceiveDataAvailableCancel"));

 	iBusDevComm->NotifyReceiveDataAvailableCancel();

 	}

 void CT_RBusDevCommData::DoCmdNotifySignalChange(const TDesC& aSection, const TInt aAsyncErrorIndex)

 	{

 	TInt	timeOut=0;

 	GetIntFromConfig(aSection, KFldTimeOut, timeOut);

 	iHasNotifySignalsExpected=GetOrFromConfig(aSection, KFldExpected(), iEnumTableSignals, iNotifySignalsExpected);

 	TUint	mask;

 	if ( GetOrFromConfig(aSection, KFldMask(), iEnumTableSignals, mask) )

 		{

 		INFO_PRINTF1(_L("NotifySignalChange with mask"));

 		iBusDevComm->NotifySignalChange(iCallbackNotifySignalChange->iStatus, iNotifySignals, mask);

 		}

 	else

 		{

 		INFO_PRINTF1(_L("NotifySignalChange without mask"));

 		iBusDevComm->NotifySignalChange(iCallbackNotifySignalChange->iStatus, iNotifySignals);

 		}

 	iCallbackNotifySignalChange->Activate(aAsyncErrorIndex, timeOut);

 	IncOutstanding();

 	}

 void CT_RBusDevCommData::DoCmdNotifySignalChangeCancel()

 	{

 	INFO_PRINTF1(_L("NotifySignalChangeCancel"));

 	iBusDevComm->NotifySignalChangeCancel();

 	}

 TInt CT_RBusDevCommData::DoCmdOpen(const TDesC& aSection)

 	{

 	TBool	dataOk=ETrue;

 	TPtrC	pdd;

 	if ( GetStringFromConfig(aSection, KFldPortPDD, pdd) && pdd.Length()!=0 )

 		{

 		TInt	errLoad=User::LoadPhysicalDevice(pdd);

 		if ( (errLoad!=KErrNone) && (errLoad!=KErrAlreadyExists) )

 			{

 			dataOk=EFalse;

 			ERR_PRINTF3(KLogLoadPhysicalDeviceError, &pdd, errLoad);

 			SetBlockResult(EFail);

 			}

 		}

 	TPtrC	ldd;

 	if ( GetStringFromConfig(aSection, KFldPortLDD, ldd) && ldd.Length()!=0 )

 		{

 		TInt	errLoad=User::LoadLogicalDevice(ldd);

 		if ( (errLoad!=KErrNone) && (errLoad!=KErrAlreadyExists) )

 			{

 			dataOk=EFalse;

 			ERR_PRINTF3(KLogLoadLogicalDeviceError, &ldd, errLoad);

 			SetBlockResult(EFail);

 			}

 		}

 	TInt	unit;

 	if ( !GetIntFromConfig(aSection, KFldUnit, unit) )

 		{

 		dataOk=EFalse;

 		ERR_PRINTF2(KLogMissingParameter, &KFldUnit());

 		SetBlockResult(EFail);

 		}

 	TInt	err=KErrNone;

 	if ( dataOk )

 		{

 		INFO_PRINTF1(_L("Open"));

 		err=iBusDevComm->Open(unit);

 		}

 	return err;

 	}

 TInt CT_RBusDevCommData::DoCmdQueryReceiveBuffer(const TDesC& aSection)

 	{

 	INFO_PRINTF1(_L("QueryReceiveBuffer"));

 	TInt	actual=iBusDevComm->QueryReceiveBuffer();

 	TInt	ret=KErrNone;

 	if ( actual<0 )

 		{

 		ret=actual;

 		}

 	else

 		{

 		TInt	expected;

 		if ( GetIntFromConfig(aSection, KFldExpected(), expected) )

 			{

 			if ( expected!=actual )

 				{

 				ERR_PRINTF1(KLogErrorExpectedValue);

 				SetBlockResult(EFail);

 				}

 			}

 		TBool	isEmpty;

 		if ( GetBoolFromConfig(aSection, KFldIsEmpty(), isEmpty) )

 			{

 			if ( isEmpty )

 				{

 				if ( actual!=0 )

 					{

 					ERR_PRINTF1(KLogErrorExpectedValue);

 					SetBlockResult(EFail);

 					}

 				}

 			else

 				{

 				if ( actual==0 )

 					{

 					ERR_PRINTF1(KLogErrorExpectedValue);

 					SetBlockResult(EFail);

 					}

 				}

 			}

 		TBool	save=EFalse;

 		GetBoolFromConfig(aSection, KFldSave(), save);

 		if ( save )

 			{

 			iBufferLength=actual;

 			}

 		}

 	return ret;

 	}

 void CT_RBusDevCommData::DoCmdReadL(const TDesC& aSection, const TInt aAsyncErrorIndex)

 	{

 	TInt	timeOut=0;

 	GetIntFromConfig(aSection, KFldTimeOut, timeOut);

 	TBool	useLength=EFalse;

 	GetBoolFromConfig(aSection, KFldUseLength(), useLength);

 	PrepareReadExpectedBufferLengthL(*iCallbackRead, aSection);

 	if ( iBufferLength>0 )

 		{

 		delete iBufferRead;

 		iBufferRead=HBufC8::New(iBufferLength);

 		iBufferReadPtr.Set(iBufferRead->Des());

 		if ( useLength )

 			{

 			INFO_PRINTF2(_L("Read with length %d"), iBufferLength);

 			iBusDevComm->Read(iCallbackRead->iStatus, iBufferReadPtr, iBufferLength);

 			}

 		else

 			{

 			INFO_PRINTF1(_L("Read without length"));

 			iBusDevComm->Read(iCallbackRead->iStatus, iBufferReadPtr);

 			}

 		iCallbackRead->Activate(aAsyncErrorIndex, timeOut);

 		IncOutstanding();

 		}

 	}

 void CT_RBusDevCommData::DoCmdReadCancel()

 	{

 	INFO_PRINTF1(_L("ReadCancel"));

 	iBusDevComm->ReadCancel();

 	}

 void CT_RBusDevCommData::DoCmdReadOneOrMoreL(const TDesC& aSection, const TInt aAsyncErrorIndex)

 	{

 	TInt	timeOut=0;

 	GetIntFromConfig(aSection, KFldTimeOut, timeOut);

 	PrepareReadExpectedBufferLengthL(*iCallbackReadOneOrMore, aSection);

 	if ( iBufferLength>0 )

 		{

 		delete iBufferRead;

 		iBufferRead=HBufC8::New(iBufferLength);

 		iBufferReadPtr.Set(iBufferRead->Des());

 		iBufferReadPtr.SetLength(iBufferLength);

 		iBufferReadOneOrMorePtr.Set(iBufferRead->Des());

 		iBufferReadOneOrMorePtr.SetLength(iBufferLength);

 		iReadOneOrMoreLeft=iBufferLength;

 		INFO_PRINTF2(_L("iBufferLength=%d"), iBufferLength);

 		INFO_PRINTF2(_L("iBufferRead->MaxLength=%d"), iBufferRead->Des().MaxLength());

 		INFO_PRINTF2(_L("iBufferReadPtr.Length=%d"), iBufferReadPtr.Length());

 		INFO_PRINTF2(_L("iBufferReadPtr.MaxLength=%d"), iBufferReadPtr.MaxLength());

 		INFO_PRINTF1(_L("ReadOneOrMore"));

 		iBusDevComm->ReadOneOrMore(iCallbackReadOneOrMore->iStatus, iBufferReadPtr);

 		iCallbackReadOneOrMore->Activate(aAsyncErrorIndex, timeOut);

 		IncOutstanding();

 		}

 	}

 void CT_RBusDevCommData::DoCmdReceiveBufferLength(const TDesC& aSection)

 	{

 	TInt	actual=iBusDevComm->ReceiveBufferLength();

 	INFO_PRINTF2(_L("ReceiveBufferLength : %d"), actual);

 	TInt	expected;

 	if ( GetIntFromConfig(aSection, KFldExpected(), expected) )

 		{

 		if ( expected!=actual )

 			{

 			ERR_PRINTF1(KLogErrorExpectedValue);

 			SetBlockResult(EFail);

 			}

 		}

 	TBool	save=EFalse;

 	GetBoolFromConfig(aSection, KFldSave(), save);

 	if ( save )

 		{

 		iReceiveBufferLength=actual;

 		}

 	}

 void CT_RBusDevCommData::DoCmdResetBuffers()

 	{

 	INFO_PRINTF1(_L("ResetBuffers"));

 	iBusDevComm->ResetBuffers();

 	}

 TInt CT_RBusDevCommData::DoCmdSetConfigL(const TDesC& aSection)

 	{

 	TInt	ret=KErrNone;

 	TPtrC	dataName;

 	if ( GetStringFromConfig(aSection, KFldConfig, dataName) )

 		{

 		CT_TCommConfigV01Data*	wrapper=static_cast<CT_TCommConfigV01Data*>(GetDataWrapperL(dataName));

 		TDes8*					data=wrapper->Descriptor();

 		if ( data!=NULL )

 			{

 			INFO_PRINTF1(_L("SetConfig"));

 			ret=iBusDevComm->SetConfig(*data);

 			}

 		else

 			{

 			ERR_PRINTF2(KLogNullConfigData, &dataName);

 			SetBlockResult(EFail);

 			}

 		}

 	else

 		{

 		ERR_PRINTF2(KLogMissingParameter, &KFldConfig());

 		SetBlockResult(EFail);

 		}

 	return ret;

 	}

 TInt CT_RBusDevCommData::DoCmdSetMinTurnaroundTime(const TDesC& aSection)

 	{

 	TUint	value=iMinTurnaroundTime;

 	GetUintFromConfig(aSection, KFldValue(), value);

 	INFO_PRINTF1(_L("SetMinTurnaroundTime"));

 	return iBusDevComm->SetMinTurnaroundTime(value);

 	}

 TInt CT_RBusDevCommData::DoCmdSetReceiveBufferLength(const TDesC& aSection)

 	{

 	TInt	value=iReceiveBufferLength;

 	GetIntFromConfig(aSection, KFldValue(), value);

 	INFO_PRINTF1(_L("SetReceiveBufferLength"));

 	return iBusDevComm->SetReceiveBufferLength(value);

 	}

 void CT_RBusDevCommData::DoCmdSetSignals(const TDesC& aSection)

 	{

 	TUint	setMask=iSignals;

 	GetOrFromConfig(aSection, KFldSetMask(), iEnumTableSignals, setMask);

 	TUint	clearMask=~setMask;

 	GetOrFromConfig(aSection, KFldClearMask(), iEnumTableSignals, clearMask);

 	INFO_PRINTF1(_L("SetSignals"));

 	iBusDevComm->SetSignals(setMask, clearMask);

 	}

 void CT_RBusDevCommData::DoCmdSignals(const TDesC& aSection)

 	{

 	TUint	actual=iBusDevComm->Signals();

 	INFO_PRINTF2(_L("Signals:0x%x"), actual);

 	TUint	expected;

 	if ( GetOrFromConfig(aSection, KFldExpected(), iEnumTableSignals, expected) )

 		{

 		if ( expected!=actual )

 			{

 			ERR_PRINTF1(KLogErrorExpectedValue);

 			SetBlockResult(EFail);

 			}

 		}

 	TBool	save=EFalse;

 	GetBoolFromConfig(aSection, KFldSave(), save);

 	if ( save )

 		{

 		iSignals=actual;

 		}

 	}

 void CT_RBusDevCommData::DoCmdVersionRequired(const TDesC& aSection)

 	{

 	TVersion				version=iBusDevComm->VersionRequired();

 	TBuf<KMaxVersionName>	versionName(version.Name());

 	INFO_PRINTF2(_L("Version name  : %S"), &versionName);

 	INFO_PRINTF2(_L("Version build : %d"), (TInt)version.iBuild);

 	INFO_PRINTF2(_L("Version major : %d"), (TInt)version.iMajor);

 	INFO_PRINTF2(_L("Version minor : %d"), (TInt)version.iMinor);

 	TPtrC	expectedVersionName;

 	if( GetStringFromConfig(aSection, KFldVersionName(), expectedVersionName) )

 		{

 		if( version.Name() != expectedVersionName )

 			{

 			ERR_PRINTF3(_L("Expected Version Name (%S) != Actual Version Name (%S)"), &expectedVersionName, &versionName);

 			SetBlockResult(EFail);	

 			}

 		}

 	TInt	intTemp;

 	if( GetIntFromConfig(aSection, KFldVersionBuild(), intTemp) )

 		{

 		if( version.iBuild != intTemp )

 			{

 			ERR_PRINTF3(_L("Expected Version Build (%d) != Actual Version Build (%d)"), intTemp, version.iBuild);

 			SetBlockResult(EFail);

 			}

 		}

 	if( GetIntFromConfig(aSection, KFldVersionMajor(), intTemp) )

 		{

 		if( version.iMajor != intTemp )

 			{

 			ERR_PRINTF3(_L("Expected Version Major (%d) != Actual Version Major (%d)"), intTemp, version.iMajor);

 			SetBlockResult(EFail);

 			}

 		}

 	if( GetIntFromConfig(aSection, KFldVersionMinor(), intTemp) )

 		{

 		if( version.iMinor != intTemp )

 			{

 			ERR_PRINTF3(_L("Expected Version Minor (%d) != Actual Version Minor (%d)"), intTemp, version.iMinor);

 			SetBlockResult(EFail);

 			}

 		}

 	if (version.Name() == _L("") && version.iBuild == 0 && version.iMajor == 0 && version.iMinor == 0)

 		{

 		ERR_PRINTF1(_L("Some version fields are not set!"));

 		SetBlockResult(EFail);

 		}

 	}

 void CT_RBusDevCommData::DoCmdWriteL(const TDesC& aSection, const TInt aAsyncErrorIndex)

 	{

 	TBool	dataOk=ETrue;

 	TBool	useLength=EFalse;

 	GetBoolFromConfig(aSection, KFldUseLength(), useLength);

 	TInt	timeOut=0;

 	GetIntFromConfig(aSection, KFldTimeOut, timeOut);

 	TInt	repeat=1;

 	GetIntFromConfig(aSection, KFldRepeat, repeat);

 	TPtrC	data;

 	if ( GetStringFromConfig(aSection, KFldData, data) )

 		{

 		iCallbackWrite->PrepareFromStringL(repeat, data);

 		}

 	else

 		{

 		if ( GetStringFromConfig(aSection, KFldFile, data) )

 			{

 			iCallbackWrite->PrepareFromFileL(repeat, data);

 			}

 		else

 			{

 			dataOk=EFalse;

 			ERR_PRINTF2(KLogMissingParameter, &KFldData);

 			ERR_PRINTF2(KLogMissingParameter, &KFldFile);

 			SetBlockResult(EFail);

 			}

 		}

 	if ( dataOk )

 		{

 		iBufferLength=iCallbackWrite->BufferLength();

 		if ( useLength )

 			{

 			INFO_PRINTF2(_L("Write with length %d"), iBufferLength);

 			iBusDevComm->Write(iCallbackWrite->iStatus, iCallbackWrite->Buffer(), iBufferLength);

 			}

 		else

 			{

 			INFO_PRINTF1(_L("Write without length"));

 			iBusDevComm->Write(iCallbackWrite->iStatus, iCallbackWrite->Buffer());

 			}

 		iCallbackWrite->Activate(aAsyncErrorIndex, timeOut);

 		IncOutstanding();

 		}

 	}

 void CT_RBusDevCommData::DoCmdWriteCancel()

 	{

 	INFO_PRINTF1(_L("WriteCancel"));

 	iBusDevComm->WriteCancel();

 	}

 void CT_RBusDevCommData::RunL(CActive* aActive, TInt aIndex)

 /**

  Virtual RunL - Called on completion of an asynchronous command

  @internalComponent

  @see MTPActiveCallback

  @param aActive Active Object that RunL has been called on

  @pre N/A

  @post N/A

  @leave system wide error code

 */

 	{

 	TBool	activeOk=ETrue;

 	TInt	err=KErrNone;

 	if ( aActive!=NULL )

 		{

 		err=aActive->iStatus.Int();

 		}

 	if ( aActive==iCallbackRead )

 		{

 		iCallbackRead->KillTimer();

 		INFO_PRINTF1(_L("RunL: Read()"));

 		if ( err==KErrNone )

 			{

 			TInt	length=iBufferReadPtr.Length();

 			HBufC*	bufferRead=HBufC::NewLC(length);

 			bufferRead->Des().Copy(iBufferReadPtr);

 			INFO_PRINTF2(_L("Received Data Length:%d"), length);

 			if ( iHasReadExpected )

 				{

 				const TDesC8&	expectedBuffer=iCallbackRead->Buffer();

 				if ( expectedBuffer.Match(iBufferReadPtr)!=0 )

 					{

 					for ( TInt index=0; index<length; ++index )

 						{

 						const TUint8&	actual=(*iBufferRead)[index];

 						const TUint8&	expected=expectedBuffer[index];

 						if ( actual!=expected )

 							{

 							ERR_PRINTF4(_L("Index:%d Read:%d Expected:%d"), index, (TInt)actual, (TInt)expected);

 							SetBlockResult(EFail);

 							}

 						}

 					}

 				}

 			CleanupStack::PopAndDestroy(bufferRead);

 			}

 		}

 	else if ( aActive==iCallbackReadOneOrMore )

 		{

 		INFO_PRINTF1(_L("RunL: ReadOneOrMore()"));

 		if ( err==KErrNone )

 			{

 			TInt	length=iBufferReadPtr.Length();

 			if ( iReadOneOrMoreLeft!=length )

 				{

 				iBufferReadPtr.SetLength(iReadOneOrMoreLeft);

 				iReadOneOrMoreLeft-=length;

 				INFO_PRINTF2(_L("iReadOneOrMoreLeft:%d"), iReadOneOrMoreLeft);

 				iBufferReadPtr.Set(iBufferReadPtr.RightTPtr(iReadOneOrMoreLeft));

 				iBufferReadPtr.SetLength(iReadOneOrMoreLeft);

 				INFO_PRINTF1(_L("ReadOneOrMore"));

 				iBusDevComm->ReadOneOrMore(iCallbackReadOneOrMore->iStatus, iBufferReadPtr);

 				iCallbackReadOneOrMore->Activate(aIndex);

 				IncOutstanding();

 				}

 			else

 				{

 				iCallbackReadOneOrMore->KillTimer();

 				HBufC*	bufferRead=HBufC::NewLC(iBufferLength);

 				bufferRead->Des().Copy(iBufferReadOneOrMorePtr);

 				if ( iHasReadExpected )

 					{

 					const TDesC8&	expectedBuffer=iCallbackReadOneOrMore->Buffer();

 					if ( expectedBuffer.Match(iBufferReadOneOrMorePtr)!=0 )

 						{

 						for ( TInt index=0; index<iBufferLength; ++index )

 							{

 							const TUint8&	actual=(*iBufferRead)[index];

 							const TUint8&	expected=expectedBuffer[index];

 							if ( actual!=expected )

 								{

 								ERR_PRINTF4(_L("Index:%d Read:%d Expected:%d"), index, (TInt)actual, (TInt)expected);

 								}

 							}

 						ERR_PRINTF1(KLogErrorExpectedValue);

 						SetBlockResult(EFail);

 						}

 					}

 				CleanupStack::PopAndDestroy(bufferRead);

 				}

 			}

 		}

 	else if ( aActive==iCallbackBreak )

 		{

 		iCallbackBreak->KillTimer();

 		INFO_PRINTF1(_L("RunL: Break()"));

 		}

 	else if ( aActive==iCallbackNotifySignalChange )

 		{

 		iCallbackNotifySignalChange->KillTimer();

 		INFO_PRINTF1(_L("RunL: NotifySignalChange()"));

 		if ( err==KErrNone )

 			{

 			INFO_PRINTF2(_L("Signals Changed=0x%x"), iNotifySignals);

 			if ( iHasNotifySignalsExpected )

 				{

 				if ( iNotifySignals!=iNotifySignalsExpected )

 					{

 					ERR_PRINTF3(KLogErrorExpectedSignal, iNotifySignals, iNotifySignalsExpected);

 					SetBlockResult(EFail);

 					}

 				}

 			}

 		}

 	else if ( aActive==iCallbackWrite )

 		{

 		iCallbackWrite->KillTimer();

 		INFO_PRINTF1(_L("RunL: Write()"));

 		}

 	else if ( aActive==iCallbackNotifyReceiveDataAvailable )

 		{

 		iCallbackNotifyReceiveDataAvailable->KillTimer();

 		INFO_PRINTF1(_L("RunL: NotifyReceiveDataAvailable()"));

 		}

 	else

 		{

 		CT_RBusLogicalChannelData::RunL(aActive, aIndex);

 		activeOk=EFalse;

 		}

 	if ( activeOk )

 		{

 		DecOutstanding();

 		}

 	if ( err!=KErrNone )

 		{

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

 		SetAsyncError(aIndex, err);

 		}

 	}

 void CT_RBusDevCommData::DoCancel(CActive* aActive, TInt aIndex)

 /**

  Virtual DoCancel - Request to cancel the asynchronous command

  @internalComponent

  @see - MTPActiveCallback

  @param aActive Active Object that DoCancel has been called on

  @pre - N/A

  @post - N/A

  @leave system wide error code

 */

 	{

 	TBool	activeOk=ETrue;

 	SetBlockResult(EFail);

 	if ( aActive==iCallbackRead )

 		{

 		ERR_PRINTF1(_L("ReadCancel Called"));

 		iBusDevComm->ReadCancel();

 		}

 	else if ( aActive==iCallbackReadOneOrMore )

 		{

 		ERR_PRINTF1(_L("ReadCancel Called"));

 		iBusDevComm->ReadCancel();

 		}

 	else if ( aActive==iCallbackBreak )

 		{

 		ERR_PRINTF1(_L("BreakCancel Called"));

 		iBusDevComm->BreakCancel();

 		}

 	else if ( aActive==iCallbackNotifySignalChange )

 		{

 		ERR_PRINTF1(_L("NotifySignalChangeCancel Called"));

 		iBusDevComm->NotifySignalChangeCancel();

 		}

 	else if ( aActive==iCallbackWrite )

 		{

 		ERR_PRINTF1(_L("WriteCancel Called"));

 		iBusDevComm->WriteCancel();

 		}

 	else if ( aActive==iCallbackNotifyReceiveDataAvailable )

 		{

 		ERR_PRINTF1(_L("NotifyReceiveDataAvailableCancel Called"));

 		iBusDevComm->NotifyReceiveDataAvailableCancel();

 		}

 	else

 		{

 		activeOk=EFalse;

 		CT_RBusLogicalChannelData::DoCancel(aActive, aIndex);

 		}

 	if ( activeOk )

 		{

 		DecOutstanding();

 		}

 	}