// Copyright (c) 1995-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 <e32std.h>

#include <e32base.h>

#define __KERNEL_MODE__

#include <kernel.h>

#undef  __KERNEL_MODE__

#include <d32comm.h>

#include <e32ver.h>

#include "d_comm.h"

#include <e32hal.h>

#include "DParams.h"

const TUint KXoffSignal=0x80000000;

//

const TInt KInputHeldFree=(-1);

const TInt KInputHeld=(-2);

//

const TUint KTransmitting=0x01;

const TUint KBreaking=0x02;

const TUint KBreakPending=0x04;

//

enum TPanic

	{

	ESetConfigWhileRequestPending,

	ESetSignalsSetAndClear,

	EResetBuffers,

	ESetReceiveBufferLength,

//	EDoubleTxBufFill,

	};

EXPORT_C DLogicalDevice *CreateLogicalDevice()

//

// Create a new device

//

	{

	return(new DDeviceComm);

	}

DDeviceComm::DDeviceComm()

//

// Constructor

//

	{

	//iParseMask=KDeviceAllowAll;

	iParseMask=KDeviceAllowUnit|KDeviceAllowInfo;

	iUnitsMask=0xffffffff; // Leave units decision to the driver

	iVersion=TVersion(KCommsMajorVersionNumber,KCommsMinorVersionNumber,KCommsBuildVersionNumber);

	}

TInt DDeviceComm::Install()

//

// Install the device driver.

//

	{

    TPtrC name=_L("CommDCE");

	return(SetName(&name));

	}

void DDeviceComm::GetCaps(TDes8 &aDes) const

//

// Return the Comm capabilities.

//

	{

	TCapsDevCommV01 b;

	b.version=iVersion;

	aDes.FillZ(aDes.MaxLength());

	aDes.Copy((TUint8 *)&b,Min(aDes.MaxLength(),sizeof(b)));

	}

DLogicalChannel *DDeviceComm::CreateL()

//

// Create a channel on the device.

//

	{

	return(new(ELeave) DChannelComm(this));

	}

#pragma warning( disable : 4705 )	// statement has no effect

#pragma warning( disable : 4355 )	// this used in intializer list

DChannelComm::DChannelComm(DLogicalDevice *aDevice)

//

// Constructor

//

: DLogicalChannel(aDevice)

	{

	SetBehaviour(RBusDevComm::ERequestReadCancel|

		RBusDevComm::ERequestWriteCancel|

		RBusDevComm::ERequestBreakCancel|

		RBusDevCommDCE::ERequestNotifySignalChangeCancel|

		RBusDevCommDCE::ERequestNotifyFlowControlChangeCancel|

		RBusDevCommDCE::ERequestNotifyConfigChangeCancel);

//

// Setup the default config

//

	iConfig.iRate=DUMMYCONFIGRATE;

	iConfig.iDataBits=DUMMYDATABITS;

	iConfig.iStopBits=DUMMYSTOPBITS;

	iConfig.iHandshake=DUMMYHANDSHAKE;

	}

#pragma warning( default : 4705 )

#pragma warning( disable : 4355 )

DChannelComm::~DChannelComm()

//

// Destructor

//

	{

	CompleteAll(KErrAbort);

	delete iDriver;

	}

void DChannelComm::DoCreateL(TInt /*aUnit*/,CBase *aDriver,const TDesC * /*anInfo*/,const TVersion &aVer)

//

// Create the channel from the passed info.

//

	{

	iDriver=(DComm *)aDriver; // Must do this to ensure the driver is destroyed by the destructor

	if (!User::QueryVersionSupported(TVersion(KCommsMajorVersionNumber,KCommsMinorVersionNumber,KCommsBuildVersionNumber),aVer))

		User::Leave(KErrNotSupported);

//	((DComm *)aDriver)->SetComm(this); // Rog

	}

void DChannelComm::DoCancel(TInt aReqNo)

//

// Cancel an outstanding request.

//

	{

	switch (aReqNo)

		{

	case RBusDevComm::ERequestRead:

		iRxDataAvailablePending=EFalse;

		break;

	case RBusDevCommDCE::ERequestNotifySignalChange:

		iSignalCount++;

		iSignalNotifyPending=EFalse;

		break;

	case RBusDevCommDCE::ERequestNotifyFlowControlChange:

		iFlowControlChangePending=EFalse;

		break;

	case RBusDevCommDCE::ERequestNotifyConfigChange:

		iConfigChangePending=EFalse;

		break;

	default:

		__ASSERT_ALWAYS(0,User::Invariant());

		}

	}

void DChannelComm::DoRequest(TInt aReqNo,TAny *a1,TAny *a2)

//

// Async requests.

//

	{

	aReqNo &= (~KDataAvailableNotifyFlag);

	switch (aReqNo)

		{

	case RBusDevCommDCE::ERequestWrite:

		{

		__ASSERT_ALWAYS(iWritePending==EFalse,User::Invariant());

		iWritePending=ETrue;

		iQueuedWrite.OneShotInMicroSeconds(KDummyTimeOut,DChannelComm::WriteCompleted,this);

		}

		break;

	case RBusDevCommDCE::ERequestRead:	// this is the RxDataAvailable notification. Base have chosen

									// to use the enum for both this and Read().

		{

		__ASSERT_ALWAYS(iRxDataAvailablePending==EFalse,User::Invariant());

		iRxDataAvailablePending=ETrue;

		iQueuedRxDataAvailable.OneShotInMicroSeconds(KDummyTimeOut,DChannelComm::RxDataAvailableCompleted,this);

		}

		break;

	case RBusDevCommDCE::ERequestNotifySignalChange:

		{

		__ASSERT_ALWAYS(iSignalNotifyPending==EFalse,User::Invariant());

		iSignalNotifyPending=ETrue;

		switch (iSignalCount)

			{

		case 0:

		case 2:

			__ASSERT_ALWAYS(*((TUint*)a2) == (DUMMYSIGNALMASK),User::Invariant());	// and wait for cancel

			break;

		case 1:

			__ASSERT_ALWAYS(*((TUint*)a2) == (DUMMYSIGNALMASK|KSignalBreak),User::Invariant());// and wait for cancel

			break;

		case 3:

		case 4:

			{

			iSignals=(TUint*)a1;

			iSignalMask=*((TUint*)a2);

			iQueuedSignalNotify.OneShotInMicroSeconds(KDummyTimeOut,DChannelComm::SignalChangeCompleted,this);

			break;

			}

		default:

			__ASSERT_ALWAYS(0,User::Invariant());

			}

		break;

	case RBusDevCommDCE::ERequestNotifyFlowControlChange:

		{

		__ASSERT_ALWAYS(iFlowControlChangePending==EFalse,User::Invariant());

		iFlowControlChangePending=ETrue;

		iQueuedFlowControl.OneShotInMicroSeconds(KDummyTimeOut,DChannelComm::FlowControlChangeCompleted,this);

		}

		break;

	case RBusDevCommDCE::ERequestNotifyConfigChange:

		{

		__ASSERT_ALWAYS(iConfigChangePending==EFalse,User::Invariant());

		iConfigChangePending=ETrue;

		iConfigPointer = (TCommNotificationPckg*)a1;

		iQueuedConfigChange.OneShotInMicroSeconds(KDummyTimeOut,DChannelComm::ConfigChangeCompleted,this);

		}

		break;

	default:

		Complete(aReqNo,KErrNotSupported);

		}

		}

	}

TInt DChannelComm::DoControl(TInt aFunction,TAny *a1,TAny* /*a2*/)

//

// Sync requests.

//

	{

	TInt r=KErrNone;

	switch (aFunction)

		{

	case RBusDevCommDCE::EControlFlowControlStatus:

		{

		iFlowControl=DUMMYFLOWCONTROLSTATUS;

		*((TFlowControl*)a1) = iFlowControl;

		}

		break;

	case RBusDevCommDCE::EControlSetConfig:

		break;

	default:

		r=KErrNotSupported;

		}

	return(r);

	}

void DChannelComm::SignalChangeCompleted(TAny* aChannel,TInt)

	{

	DChannelComm* dc = (DChannelComm*)aChannel;

	dc->SetSignals();

	dc->CompleteReq(RBusDevCommDCE::ERequestNotifySignalChange);

	}

void DChannelComm::ConfigChangeCompleted(TAny* aChannel,TInt)

	{

	DChannelComm* dc = (DChannelComm*)aChannel;

	dc->ChangeConfig();

	dc->CompleteReq(RBusDevCommDCE::ERequestNotifyConfigChange);

	}

void DChannelComm::RxDataAvailableCompleted(TAny* aChannel,TInt)

	{

	((DChannelComm*)aChannel)->CompleteReq(RBusDevCommDCE::ERequestRead);

	}

void DChannelComm::FlowControlChangeCompleted(TAny* aChannel,TInt)

	{

	((DChannelComm*)aChannel)->CompleteReq(RBusDevCommDCE::ERequestNotifyFlowControlChange);

	}

void DChannelComm::WriteCompleted(TAny* aChannel,TInt)

	{

	((DChannelComm*)aChannel)->CompleteReq(RBusDevCommDCE::ERequestWrite);

	}

void DChannelComm::CompleteReq(TInt aReqNo)

	{

	Complete(aReqNo);

	}

void DChannelComm::SetSignals()

	{

	switch(iSignalCount++)

		{

	case 3:

		(*iSignals)=DUMMYSIGNALS;

		break;

	case 4:

		(*iSignals)=(KSignalBreak|KBreakChanged);

		break;

	default:

		__ASSERT_ALWAYS(0,User::Invariant());

		};

	iSignalNotifyPending=EFalse;

	}

void DChannelComm::ChangeConfig()

	{

	iConfig.iChangedMembers = DUMMYCHANGED;

	iConfigPointer->FillZ(iConfigPointer->MaxLength());

	TInt len=Min(iConfigPointer->MaxLength(),sizeof(iConfig));

	iConfigPointer->Copy((TUint8 *)&iConfig,len);

	}