// Copyright (c) 2006-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:

//

/**

 @file

 @internalComponent

*/

#include "hctlbcsp.h"

#include "hctlbcspFrameQueue.h"

#include "bcsputils.h"

#include "hctlbcspframe.h"

#include "hctlbcspconsts.h"

#include "linkestablishment.h"

#include "hctlbcspreceiver.h"

#include "hctlbcspsequencer.h"

#include "hctlbcspcontrollermanager.h"

#include "debug.h"

#include <bluetooth/hci/hcierrors.h>

#include <bluetooth/hci/hcievents.h>

#include <bluetooth/hci/hctlchannelobserver.h>

#include <bluetooth/hci/hctldataobserver.h>

#include <bluetooth/hci/hctleventobserver.h>

/**

	Implementation of Class CHCTLBcsp

*/

CHCTLBcsp::CHCTLBcsp()

	{

	LOG_FUNC

	}

CHCTLBcsp::~CHCTLBcsp()

	{

	LOG_FUNC

	HCI_LOG_UNLOAD(this);

	delete iLinkEstablishment;

	delete iReceiver;

	delete iSequencer;

	delete iFrameQueue;

	delete iReceivedFrame;

	delete iControllerMan;

	}

CHCTLBcsp* CHCTLBcsp::NewL()

	{

	LOG_STATIC_FUNC

	CHCTLBcsp* self=new(ELeave) CHCTLBcsp;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CHCTLBcsp::ConstructL()

	{

	LOG_FUNC

	HCI_LOG_LOADL(this, KHCILoggerDatalinkTypeH1);	// Technically it's BCSP but we're going

													// to log at a higher layer

	BaseConstructL(KIniFileName);													

	iControllerMan = CHCTLBcspControllerManager::NewL(*this, Port(), PowerCtrlMode());

	}

TAny* CHCTLBcsp::Interface(TUid aUid)

	{

	LOG_FUNC

	TAny* ret = NULL;

	switch(aUid.iUid)

		{

		case KHCTLInterfaceUid:

			ret = reinterpret_cast<TAny*>(static_cast<MHCTLInterface*>(this));

			break;

		case KHCTLPowerInterfaceUid:

			ret = reinterpret_cast<TAny*>(static_cast<MHCTLPowerInterface*>(iControllerMan));

			break;

		case KHCHardResetUid:

			ret = reinterpret_cast<TAny*>(static_cast<MHardResetInitiator*>(this));

			break;	

		default:

			break;

		};

	return ret;

	}

void CHCTLBcsp::DoConfigL()

/**

	Method to set the TCommConfigV01 settings for UART based HCTLs

	enforced implementation by pure virtual method in CHCTLUartBase to allow for the original uart transport (H4) and BCSP

	specific settings

	@leave method will leave if Port().SetConfig() fails

*/

	{

	LOG_FUNC

	Port().ResetBuffers();

	TCommConfig conf;

	Port().Config(conf);

	TCommConfigV01& config = conf(); //Get reference to TCommConfig iConfig

	config.iDataBits = EData8;				

	config.iStopBits = EStop1; 

	config.iTerminatorCount = 1;

	config.iTerminator[0] = 0xc0;

	config.iParity = EParityEven;				 

	config.iParityError = KConfigParityErrorFail;

	config.iHandshake = 0; 

	config.iXonChar = 0;

	config.iXoffChar = 0;

	LEAVEIFERRORL(Port().SetConfig(conf));

	}

//Implemenation of MHCTLInterface

TInt CHCTLBcsp::MhiWriteAclData(const TDesC8& aData)

	{

	LOG_FUNC

	iFrameQueue->AddReliableFrame(aData, KBcspACLDataChnl);

	HCI_LOG_FRAME(this, KHCILoggerHostToController | KHCILoggerACLDataFrame, aData);

	return KErrNone;

	}

TInt CHCTLBcsp::MhiWriteSynchronousData(const TDesC8& aData)

	{

	LOG_FUNC

	iFrameQueue->AddUnreliableFrame(aData, KBcspSynchronousDataChnl, 0, EFalse);

	HCI_LOG_FRAME(this, KHCILoggerHostToController | KHCILoggerSynchronousDataFrame, aData);

	return KErrNone;

	}

TInt CHCTLBcsp::MhiWriteCommand(const TDesC8& aData)	

	{

	LOG_FUNC

	TRAPD(err,DoWriteCommandL(aData));

	if(err!=KErrNone)

		{

		return KErrBcspWriteCommandDataFailed;

		}

	else

		{

		HCI_LOG_FRAME(this, KHCILoggerHostToController | KHCILoggerCommandOrEvent, aData);

		return err;

		}

	}

TInt CHCTLBcsp::WriteBcCmd(const TDesC8& aData)	

	{

	LOG_FUNC

	TRAPD(err,DoWriteBcCmdL(aData));

	if(err!=KErrNone)

		{

		return KErrBcspWriteBcCmdDataFailed;

		}

	else

		{

		HCI_LOG_FRAME(this, KHCILoggerHostToController | KHCILoggerCommandOrEvent, aData);

		return err;

		}

	}

void CHCTLBcsp::MhiSetQdpPluginInterfaceFinder(MQdpPluginInterfaceFinder& aQdpPluginInterfaceFinder)

	{

	iQdpPluginInterfaceFinder = &aQdpPluginInterfaceFinder;

	}

void CHCTLBcsp::MhriStartHardReset()

	{

	iControllerMan->HardReset();	

	}

void CHCTLBcsp::MhiGetAclDataTransportOverhead(TUint& aHeaderSize, TUint& aTrailerSize) const

	{

	aHeaderSize = KHCTLAclDataHeaderSize;

	aTrailerSize = KHCTLAclDataTrailerSize;

	}

void CHCTLBcsp::MhiGetSynchronousDataTransportOverhead(TUint& aHeaderSize, TUint& aTrailerSize) const

	{

	aHeaderSize = KHCTLSynchronousDataHeaderSize;

	aTrailerSize = KHCTLSynchronousDataTrailerSize;

	}

void CHCTLBcsp::MhiGetCommandTransportOverhead(TUint& aHeaderSize, TUint& aTrailerSize) const

	{

	aHeaderSize = KHCTLCommandHeaderSize;

	aTrailerSize = KHCTLCommandTrailerSize;

	}

//MHCTLInterface  END

void CHCTLBcsp::DoWriteCommandL(const TDesC8 &aData)

/**

	Method called from MhiWriteCommand

	@param aData

	aData is the formatted Command payload from the linkmanager

*/

	{

	LOG_FUNC

#ifdef __DEBUG_FLOG_STACK_TX_

	LOG(_L8("STACK TX"));

	LOGHEXDESC(aData);

#endif

	User::LeaveIfError(iFrameQueue->AddReliableFrame(aData, KBcspCommEvntChnl));//KBcspBcCmdChnl

	}

void CHCTLBcsp::DoWriteBcCmdL(const TDesC8 &aData)

/**

	Method called from WriteBcCmdData

	@param aData

	aData is the formatted BCCMD payload from the controller manager

*/

	{

	LOG_FUNC

#ifdef __DEBUG_FLOG_STACK_TX_

	LOG(_L8("STACK TX"));

	LOGHEXDESC(aData);

#endif

	User::LeaveIfError(iFrameQueue->AddReliableFrame(aData, KBcspBcCmdChnl));

	}

/**

Process Received data in to the format expected by the interface to the bottom of the stack

*/

void CHCTLBcsp::ProcessACLData() 

/**

	Passes ACL data to the data observer.

*/

	{

	LOG_FUNC

	__ASSERT_DEBUG(iReceivedFrame->IsValid(), PANIC(KBcspPanicCat, EBadBcspFrame));

	HCI_LOG_FRAME(this, KHCILoggerControllerToHost | KHCILoggerACLDataFrame, iReceivedFrame->Payload());

	iDataObserver->MhdoProcessAclData(iReceivedFrame->Payload());

	}

void CHCTLBcsp::ProcessEventData()

/**

	Passes event data to the data observer.

*/

	{

	LOG_FUNC

	__ASSERT_DEBUG(iReceivedFrame->IsValid(), PANIC(KBcspPanicCat, EBadBcspFrame));

	HCI_LOG_FRAME(this, KHCILoggerControllerToHost | KHCILoggerCommandOrEvent, iReceivedFrame->Payload());

	iEventObserver->MheoProcessEvent(iReceivedFrame->Payload());

	}

void CHCTLBcsp::ProcessBcCmdEventData()

/**

	Method which parses the received Command data payload from the controller

	and formats the data to be passed to the controller manager

*/

	{

	LOG_FUNC

	__ASSERT_DEBUG(iReceivedFrame->IsValid(), PANIC(KBcspPanicCat, EBadBcspFrame));

	HCI_LOG_FRAME(this, KHCILoggerControllerToHost | KHCILoggerCommandOrEvent, iReceivedFrame->Payload());

	iControllerMan->ProcessBcCmdEvent(iReceivedFrame->Payload());

	}

void CHCTLBcsp::ProcessSynchronousData()

	{

	LOG_FUNC

	__ASSERT_DEBUG(iReceivedFrame->IsValid(), PANIC(KBcspPanicCat, EBadBcspFrame));

	HCI_LOG_FRAME(this, KHCILoggerControllerToHost | KHCILoggerSynchronousDataFrame, iReceivedFrame->Payload());

	iDataObserver->MhdoProcessSynchronousData(iReceivedFrame->Payload());

	}

TInt CHCTLBcsp::PacketRouter()

/**

	Method called by CHCTLBcspReceiver after packet integrity checks have been performed

	This routes packets according to the ProtocolId associated with the payload type in a 

	given BCSP frame to the appropriate interface to the top of the HCI and thus to the 

	link manager

*/

	{

	LOG_FUNC

	TInt err = KErrNone;

	__ASSERT_DEBUG(iReceivedFrame->IsValid(), PANIC(KBcspPanicCat, EBadBcspFrame));

	switch (iReceivedFrame->ProtocolId())

		{

		case KBcspCommEvntChnl:

			{

			LOG(_L8("HCTLBCSP: Event Packet Received..."));

			ProcessEventData();

			}

			break;

		case KBcspBcCmdChnl:

			{

			LOG(_L8("HCTLBCSP: BC Command Packet Received..."));

			ProcessBcCmdEventData();

			}

			break;

		case KBcspACLDataChnl:

			{

			LOG(_L8("HCTLBCSP: ACL Data Packet Received..."));

			ProcessACLData();

			}

			break;

		case KBcspSynchronousDataChnl:

			{

			LOG(_L8("HCTLBCSP: Synchronous Data Packet Received..."));

			ProcessSynchronousData();

			}

			break;

		case KBcspLinkChnl:

			{

			LOG(_L8("HCTLBCSP: Link Est Packet Received..."));

			__ASSERT_DEBUG(iLinkEstablishment!=NULL, PANIC(KBcspPanicCat, EBadLinkPointer));

			TRAP(err,iLinkEstablishment->ProcessLinkMsg(iReceivedFrame->Payload()));

			}	

			break;

		default:

			LOG(_L8("HCTLBCSP: ERROR: KErrBcspUnRecognizableHCIData..."));

			break;

		};

	return err;

	}

void CHCTLBcsp::QueueReadForNextFrame()

	{

	LOG_FUNC

	iReceiver->QueueReadForNextFrame();

	}

void CHCTLBcsp::CanSend(TBool aCanSend)

/**

	For BCSP this is always taken to be all channels or no channels

*/

	{

	LOG_FUNC

	iCanSend = aCanSend;

	// We can only open the channel after unchoked and iChannelObserver has been set

	if(!iChoked && iChannelObserver)

		{

		if(iCanSend)

			{

			iChannelObserver->MhcoChannelOpen(KHCITransportAllChannels);

			}

		else

			{

			iChannelObserver->MhcoChannelClosed(KHCITransportAllChannels);

			}

		}

	}

void CHCTLBcsp::TxAckMsg()

/**

	Method to send a BCSP Ack message

	This is only called when an the Ack timer fires i.e. a certain amount of time has

	passed without there being an outgoing BCSP frame to convey acknowledgement of received 

	reliable frames

*/

	{	

	LOG_FUNC

	iFrameQueue->AddUnreliableFrame(KBcspAckChnl, iSequencer->TxAck(), EFalse);

	}

void CHCTLBcsp::TxLinkMsg(const TDesC8& aData)

/**

	This is a method that takes a BCSP Link Establishment message as its parameter

	and adds the data along with a number of other bits of information to make a frame 

	on the Unreliable frame queue via the iFrameQueue::AddUnreliableFrame() method

*/

	{	

	LOG_FUNC

	iFrameQueue->AddUnreliableFrame(aData, KBcspLinkChnl, 0, ETrue);

	}

TInt CHCTLBcsp::HandleRx(const TDesC8 &aReceivedFrame)

/**

	This is a method called from the CHCTLBcspReceiver::ProcessDataL()

	with the parameter

	@param const TDesC8 &aReceivedFrame

	@return err

	This method attempts to slip decode the received frame 

	Then if that is successful the remainder of the BCSP frame integrity checks are performed

	using the iReceivedFrame->IsValid() method

	Assuming that this all works without errors control is then passed to the sequencer

	via the iSequencer->HandleRx(iReceivedFrame) call

	and then the iReceivedFrame->Reset() method is called

*/

	{

	LOG_FUNC

	TInt rerr = iReceivedFrame->SlipDecodeFrame(aReceivedFrame);

	if (rerr == KErrNone)

		{

		// We've succeeded in decoding the Slip Frame into a CRxHctlBcspFrame

		__ASSERT_DEBUG(iReceivedFrame->IsValid(), PANIC(KBcspPanicCat, EBadBcspFrame));

#ifdef __DEBUG_RxDecodedFrame__

		FlogRx();

#endif

		iSequencer->HandleRx(iReceivedFrame);

		iReceivedFrame->Reset();

		}

	return rerr;

	}

TBool CHCTLBcsp::CheckIsAckPacket() const

/**

	This is a relatively simple method that examines the ProtocolId of the Received Frame

	and attempts to match it to the the KBcspAckChnl constant and then returns a TBool depending

	on whether or not these match

*/

	{

	LOG_FUNC

	return (iReceivedFrame->ProtocolId() == KBcspAckChnl);

	}

#ifdef __DEBUG_RxDecodedFrame__

void CHCTLBcsp::FlogRx()

	{

	LOG(_L8("RxFrame"));

	LOG1(_L8("Protocol type reliable(1) unreliable (0) = %d\n"),iReceivedFrame->IsReliableProtcolType());

	LOG1(_L8("Ack value = %d\n"),iReceivedFrame->Ack());

	LOG1(_L8("Seq value = %d\n"),iReceivedFrame->Sequence());

	LOG1(_L8("Protocol ID (Command/Event(5)) (ACL) (Ack Packet) = %d\n"),iReceivedFrame->ProtocolId());

	LOG1(_L8("Payload Length = %d\n"),iReceivedFrame->PayloadLength());

	LOG1(_L8("Checksum value = %d\n"),iReceivedFrame->CheckSum());

	LOG1(_L8("Header bytes = %d\n"),iReceivedFrame->FlagsField());

	LOG(_L8("Payload..."));

	LOGHEXDESC(iReceivedFrame->Payload());

	}

#endif

/**

	See comments on iChoked	

*/

void CHCTLBcsp::Choke()

	{

	LOG_FUNC

	iChoked = ETrue;

	CanSend(iCanSend);

	}

/**

	See comments on iChoked	

*/

void CHCTLBcsp::UnChoke()

	{

	LOG_FUNC

	iChoked = EFalse;

	if(iControllerMan->BcspLinkEstablished())

		{

		CanSend(iCanSend);

		}

	}

TBool CHCTLBcsp::Muzzled()

	{

	return iMuzzled;

	}

void CHCTLBcsp::ResetMuzzled()

	{

	iMuzzled = EFalse;

	}