// 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 "hctlbcspsequencer.h"

#include "hctlbcspFrameQueue.h"

#include "hctlbcsp.h"

#include "hctlbcspframe.h"

#include "hctlbcspconsts.h"

#include "hctlbcspsender.h"

#include "debug.h"

#include <bluetooth/hci/delay.h>

#define MAX_RX_TIMEOUT_ALLOWED			5

/**

Implementation of Class CHCTLBcspSequencer

*/

CHCTLBcspSequencer::CHCTLBcspSequencer(CHCTLBcsp& aHctlBcsp, CHCTLBcspFrameQueue& aBcspFrameQueue):

	iRelRxState(EIdle), 

	iHctlBcsp(aHctlBcsp),

	iFrameQueue(aBcspFrameQueue)

	{

	LOG_FUNC

	}

CHCTLBcspSequencer* CHCTLBcspSequencer::NewL(CHCTLBcsp &aHCTLBcsp, RBusDevComm& aPort, CHCTLBcspFrameQueue& aBcspFrameQueue)

	{

	LOG_STATIC_FUNC

	CHCTLBcspSequencer* self=new(ELeave) CHCTLBcspSequencer(aHCTLBcsp, aBcspFrameQueue);

    CleanupStack::PushL(self);

    self->ConstructL(aPort);

    CleanupStack::Pop();

    return self;

	}

void CHCTLBcspSequencer::ConstructL(RBusDevComm& aPort)

    {

	LOG_FUNC

	TCallBack cb = TCallBack(CHCTLBcspSequencer::RxTimeout, this);

	iRxAckTimer = CDelay::NewL(cb, CActive::EPriorityStandard);

	cb = TCallBack(CHCTLBcspSequencer::TxTimeout, this);

	iTxAckTimer = CDelay::NewL(cb, CActive::EPriorityStandard);

    iSender  = CHCTLBcspSender::NewL(*this,aPort);

    }

CHCTLBcspSequencer::~CHCTLBcspSequencer()

	{

	LOG_FUNC

	delete iRxAckTimer;

	delete iTxAckTimer;

	delete iSender;

	}

/**

  	Resets the BCSP sequencer to default state.

*/

void CHCTLBcspSequencer::Reset()

 	{

	LOG_FUNC

 	iSender->Cancel();

 	//reset rx variables

 	iRxAck = 0;

 	iRxSeq = 0;

 	iRxSeqExpected = 0;

 	iRxSeqLast = 0;

 	}

/**

  	Called when a peer reset of BCSP is detected

 	Passes the notification up the BCSP stack for handling

*/

void CHCTLBcspSequencer::HandlePeerReset()

 	{

	LOG_FUNC

 	iHctlBcsp.HandlePeerReset();

 	}

void CHCTLBcspSequencer::HandleRx(CRxHctlBcspFrame* aFrame)

	{

	LOG_FUNC

	iRelRxState = EReceiving;

	iRxSeqLast = iRxSeq;	

	iRxAck = aFrame->Ack();

	if (aFrame->IsReliableProtcolType())

		{

		iRxSeq=aFrame->Sequence();

		}

#ifdef __DEBUG_SEQ_Values__

	LOG1(_L8("\tiRxAck value = %d"),iRxAck);

	LOG1(_L8("\tiRxSeq value = %d"),iRxSeq);

	LOG1(_L8("\tiRxSeqLast value = %d"),iRxSeqLast);

	LOG1(_L8("\tiRxSeqExpected value = %d"),iRxSeqExpected);

	LOG1(_L8("\tiTxAck value = %d"),iTxAck);

#endif

	// Call HandleRxAck() to process the Ack Value conveyed in the received frame header

	HandleRxAck();

	// Check if the received frame is unreliable and on the BCSP Link Establihsment channel

	// If it is then route directly to the iHctlBcsp.PacketRouter()

	if(!aFrame->IsReliableProtcolType() && aFrame->ProtocolId() == KBcspLinkChnl) //Route LE packets

		{

#ifdef __DEBUG_SEQ_VERBOSE__ //Enable flogging for Sequencer

		LOG(_L8("HCTLBCSP: CHCTLBcspSequencer::HandleRx() Pass LE Packet to LE Entity\n\n"));

#endif

		iHctlBcsp.PacketRouter();

		return;

		}

	// Otherwise the packet is reliable and passes into this switch statement

	switch (iRelRxState)	//Verify ProtocolId is valid and permissable

		{

		case EIdle: // Fall through.

		case EReceiving:

			{

			if(iRxSeq == iRxSeqExpected && (iHctlBcsp.CheckIsAckPacket()==EFalse))

				{

				iTxAck = static_cast <TUint8>((iRxSeq+1)%8);

				iRxSeqExpected = iTxAck;

				iHctlBcsp.PacketRouter();	// Forward RxFrame to PacketRouter

				}

			//else drop the packet

			StartTxAckTimer();

			}

			break;

		default:

			break;

		};

	}

void CHCTLBcspSequencer::SendNextPacket()

/**

	This method attempts to send the next frame on the queue.

*/

	{

	LOG_FUNC

	if(SendQueuedFrame() == KErrBcspMaxRetries)

		{

		HandlePeerReset();

		}

	}

TUint8 CHCTLBcspSequencer::TxAck() const

	{

	LOG_FUNC

	return iTxAck;

	}

void CHCTLBcspSequencer::HandleRxAck()

	{

	LOG_FUNC

	// An ACK has been received, so reset the Tx timeout counter

	iRxTimeoutCount = 0;

	// Returns ETrue if there are unacknowledged packets remaining

	// in the window

	if(iFrameQueue.AckReceived(iRxAck))

		{

		StartRxAckTimer();

		}

	else

		{

		iRxAckTimer->Cancel();

		}

	}

/*static*/ TInt CHCTLBcspSequencer::RxTimeout(TAny* aThis)

	{

	LOG_STATIC_FUNC

	reinterpret_cast<CHCTLBcspSequencer*>(aThis)->HandleRxAckTimeout();

	return KErrNone;

	}

void CHCTLBcspSequencer::SendPacket(TDesC8* aFrame, TBool aIsReliable)	

/**

	This method writes @param aFrame and starts the RxAckTimer if @param aIsReliable

	is ETrue

*/

	{

	LOG_FUNC

	iSender->Write(*aFrame);	

	if (aIsReliable)

		{

		StartRxAckTimer();

		}

	}

TInt CHCTLBcspSequencer::TxTimeout(TAny* aThis)

	{

	LOG_STATIC_FUNC

	reinterpret_cast<CHCTLBcspSequencer*>(aThis)->TxAckMsg();

	return KErrNone;

	}

void CHCTLBcspSequencer::TxAckMsg() 

	{

	LOG_FUNC

	iHctlBcsp.TxAckMsg();

	}

void CHCTLBcspSequencer::StartRxAckTimer()

	{

	LOG_FUNC

	iRxAckTimer->Cancel();

	iRxAckTimer->After(KRxAckTimeout);

	}

void CHCTLBcspSequencer::StartTxAckTimer()

	{

	LOG_FUNC

	if ( !iTxAckTimer->IsActive() )

		{

		iTxAckTimer->After(KRxAckTimeout);

		}

	}

void CHCTLBcspSequencer::HandleRxAckTimeout()

	{

	LOG_FUNC

	// Increment the Rx ACK Timeout counter

	iRxTimeoutCount++;

	iFrameQueue.AckTimeout();

	// While the maximum rx timeout allowed is not reached, rearm the timer

	// waiting for the ACK.

	// If the max is reached, we consider that the peer will not respond and

	// has been poweroff. So, do not rearm the timer and reset the counter.

	// Notice that the BC4 ship implements the same mechanism.

	if (iRxTimeoutCount < MAX_RX_TIMEOUT_ALLOWED)

		{

		StartRxAckTimer();

		}

	else

		{

		iRxTimeoutCount = 0;

		}

	}

void CHCTLBcspSequencer::WakeUp()

/**

	Method made available to trigger the TxStateMachine to do something 

	depending upon its current state

*/

	{

	LOG_FUNC

	if(!iSender->IsActive())

		{

		SendNextPacket();

		}

	}

TInt CHCTLBcspSequencer::SendQueuedFrame()

/**

	Method to get the Next Frame from the frame queue and then write it via 

	the SendPacket method

*/

	{

	LOG_FUNC

	TDesC8* frame = NULL;

	TBool isReliable = EFalse;

	TInt err = iFrameQueue.GetNextFrame(frame,isReliable);

	if (!err)

		{

		SendPacket(frame,isReliable);

		}

	return err;

	}