// 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 <bluetooth/hcicmdqcontroller.h>

#include <bluetooth/hci/hciconsts.h>

#include "HciCmdQTimer.h"

#include "HciCmdQUtil.h"

#include <bluetooth/hardresetinitiator.h>

#include <bluetooth/hcicommandqitem.h>

#include <bluetooth/hcicommandqueueclient.h>

#include <bluetooth/linkmuxnotifier.h>

#include <bluetooth/hci/commandstatusevent.h>

#include <bluetooth/hci/event.h>

#include <bluetooth/hci/commandcompleteevent.h>

#include <bluetooth/hci/hcicmdqueuedecisionplugin.h>

#include <bluetooth/hci/hcicmdqueuedecisioninterface.h>

#include <bluetooth/hci/hciframe.h>

#include <bluetooth/hci/hctlinterface.h>

#include <bluetooth/hci/hciutil.h>

#include <bluetooth/hci/command.h>

#include <bluetooth/hci/hcievents.h>

#include <bluetooth/hci/completingeventquery.h>

#include <bluetooth/logger.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_HCICMDQ);

#endif

#ifdef _DEBUG

PANICCATEGORY("hcicmdqcon");

#endif

_LIT(KHciCommandQueueComponentName, "cmdq");

EXPORT_C void MHCICmdQueueUtilities::InjectEvent(const THCIEventBase& aEvent)

	{

	MhcquiInjectEvent(aEvent);

	}

EXPORT_C CHCICommandQItem* MHCICmdQueueUtilities::FindOutstandingCommand(THCIOpcode aOpcode)

	{

	return MhcquiFindOutstandingCommand(aOpcode);

	}

EXPORT_C /*static*/ CHCICmdQController* CHCICmdQController::NewL()

	{

	LOG_STATIC_FUNC

	CHCICmdQController* self = new (ELeave) CHCICmdQController();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Destructor.

*/

EXPORT_C CHCICmdQController::~CHCICmdQController()

	{

	LOG_FUNC

	// All (entry point) command queue clients should have removed any commands they added.

#if defined(_DEBUG) && defined(__FLOG_ACTIVE)

	// In debug to help debugging by logging the commands left on the queues that should be empty.

	if(!iInitCommandQ.IsEmpty())

		{

		LOG(_L("Initialisation Queue is not empty..."))

		LogQueue(iInitCommandQ);

		}

	if(!iNormalCommandQ.IsEmpty())

		{

		LOG(_L("Normal Queue is not empty..."))

		LogQueue(iNormalCommandQ);

		}

	if(!iPriorityCommandQ.IsEmpty())

		{

		LOG(_L("Priority Queue is not empty..."))

		LogQueue(iPriorityCommandQ);

		}

	if(!iWorkaroundCommandQ.IsEmpty())

		{

		LOG(_L("Workaround Queue is not empty..."))

		LogQueue(iWorkaroundCommandQ);

		}

#endif // _DEBUG && __FLOG_ACTIVE

	__ASSERT_ALWAYS(iInitCommandQ.IsEmpty(), PANIC(KHCICmdQPanic, EInitCommandQNotEmptyInDestructor));

	__ASSERT_ALWAYS(iNormalCommandQ.IsEmpty(), PANIC(KHCICmdQPanic, ENormalCommandQNotEmptyInDestructor));

	__ASSERT_ALWAYS(iPriorityCommandQ.IsEmpty(), PANIC(KHCICmdQPanic, EPriorityCommandQNotEmptyInDestructor));

	__ASSERT_ALWAYS(iWorkaroundCommandQ.IsEmpty(), PANIC(KHCICmdQPanic, EWorkaroundCommandQNotEmptyInDestructor));

	// Clean up internally managed queues

	TDblQueIter<CHCICommandQItem> sentIter(iSentCommandQ);

	CleanUpQueue(sentIter);

	TDblQueIter<CHCICommandQItem> resendIter(iResendCommandQ);

	CleanUpQueue(resendIter);

	__ASSERT_ALWAYS(iSentCommandQ.IsEmpty(), PANIC(KHCICmdQPanic, ESentCommandQNotEmptyInDestructor));

	__ASSERT_ALWAYS(iResendCommandQ.IsEmpty(), PANIC(KHCICmdQPanic, EResendCommandQNotEmptyInDestructor));

	delete iQStarvationTimer;

	delete iSendingCommand;

	delete iQdpPlugin;

	// Delete async CallBacks.	If running, these should be cancelled by the

	// d'tor of CAsyncOneShot.

	delete iAsyncCallBackForReset;

	delete iAsyncCallBackForSend;

	delete iHciUtil;

	CLOSE_LOGGER

	}

/**

Sets the HCTL interface instance to be used by the Command Queue Controller to

send command frames over the HCTL.

@param aHctlInterface An instance implementing the interface to the HCTL.

*/

EXPORT_C void CHCICmdQController::SetHCTLInterface(MHCTLInterface& aHctlInterface)

	{

	LOG_FUNC

	__ASSERT_DEBUG(!iHctl, PANIC(KHCICmdQPanic, EHctlInterfaceInitialisedTwice));

	iHctl = &aHctlInterface;

	}

/**

Sets the HCI Command Allocator interface instance to be used by the Command Queue 

Controller to create HCI command frames.

@param aCommandAllocator Implementation of command allocator interface.

*/

EXPORT_C void CHCICmdQController::SetHCICommandAllocator(MHCICommandAllocator& aCommandAllocator)

	{

	LOG_FUNC

	__ASSERT_DEBUG(!iCommandAllocator, PANIC(KHCICmdQPanic, EHciCommandAllocatorInterfaceInitialisedTwice));

	iCommandAllocator = &aCommandAllocator;

	}

/**

Sets the Link Mux Notifier interface instance to be used by the Command Queue 

Controller to provide co-ordinated sending to the HCTL.

@param aLinkMuxer An instance implementing the interface to the Link Muxer.

*/

EXPORT_C void CHCICmdQController::SetLinkMuxNotifier(MLinkMuxNotifier& aLinkMuxer)

	{

	LOG_FUNC

	__ASSERT_DEBUG(!iLinkMuxer, PANIC(KHCICmdQPanic, ELinkMuxNotifierInitialisedTwice));	

	iLinkMuxer = &aLinkMuxer;

	}

/**

Sets the command queue client that will subsequently receive unmatched events.

@param aUnmatchedEventObserver An instance implementing the command queue client interface.

*/

EXPORT_C void CHCICmdQController::SetHCIUnmatchedEventObserver(MHCICommandQueueClient& aUnmatchedEventObserver)

	{

	LOG_FUNC

	__ASSERT_DEBUG(!iUnmatchedEventObserver, PANIC(KHCICmdQPanic, EUnmatchedEventObserverInitialisedTwice));	

	iUnmatchedEventObserver = &aUnmatchedEventObserver;

	}

/**

Sets the Hard Reset Initiator interface instance to be used by the QDP. 

This will allow the QDP to request a Hard Reset.

@param aHardResetInitiator An instance implementing the interface to the Hard Reset Initiator.

*/

EXPORT_C void CHCICmdQController::SetHardResetInitiator(MHardResetInitiator& aHardResetInitiator)

	{

	LOG_FUNC

	__ASSERT_DEBUG(!iHardResetInitiator, PANIC(KHCICmdQPanic, EHardResetInitiatorInitialisedTwice));	

	iHardResetInitiator = &aHardResetInitiator;

	iQdp->MhcqdiSetHardResetInitiator(aHardResetInitiator);

	}

/**

Sets the physical links state interface instance to be used by the QDP to query the state of

physical links in the stack..

@param aStackInfo An instance implementing the interface to the physical links state information.

*/

EXPORT_C void CHCICmdQController::SetPhysicalLinksState(const MPhysicalLinksState& aStackInfo)

	{

	LOG_FUNC

	iQdp->MhcqdiSetPhysicalLinksState(aStackInfo);

	}

/**

This allows the Command Queue to start accepting commands to be queued. Whilst

in the Initialise state only Initialisation commands will be sent but other

commands will be added to the Normal and Priority queues so they can be sent

when we transition to the Started state.

@see CHCICmdQController::Start

*/

EXPORT_C void CHCICmdQController::Initialise()

	{

	LOG_FUNC

	// Can only enter the Initialising state from either the Uninitialised

	// state or the Resetting state

	switch(iCmdQControllerState)

		{

		case EUninitialised:

			iCmdQControllerState = EInitialising;

			break;

		case EResetting:

			iCmdQControllerState = EResetInit;

			break;

		default:

			PANIC(KHCICmdQPanic, EInvalidStateTransition);

			break;

		};

	}

/**

Initiates an asynchronous request for reset processing on the command queue. 

Asynchronous reset processing is performed by CHCICmdQController::DoReset(), to

empty the command queue and perform any other tasks on the Command Queue when 

the stack requests a sub-system reset. This will put the Command Queue into a 

state where no commands can be sent until CHCICmdQController::Initialise() is 

called.

@see CHCICmdQController::Initialise

*/

EXPORT_C void CHCICmdQController::Reset()

	{

	LOG_FUNC

	// Mark the tails of the queues.

	StorePurgeMarks();

	// Stop the queue starvation timer and reset the priority insert point.

	iQStarvationTimer->Cancel();

	iCmdQControllerState = EResetting;

	// Cancel the sending callback if it is currently active.

	iAsyncCallBackForSend->Cancel();

	// Call async CallBack to initiate Reset processing.

	iAsyncCallBackForReset->CallBack();

	}

/**

Signals that the Stack has finished intialising the HCI, and that it is

safe to send normal (non-initialisation) commands.

Trying to add intialisation commands after this call will result in a panic.

@see CHCICmdQController::Reset

@panic EInvalidStateTransition if not in the initialising state.

@panic EStartCalledWhenInitQNotEmpty if the method is called when the initialisation queue is not empty.

@panic EObjectNotInitialised if not all inteface references have been populated.

*/

EXPORT_C void CHCICmdQController::Start()

	{

	LOG_FUNC

	// Can only enter the Started state from the Initialising state

	__ASSERT_ALWAYS((iCmdQControllerState == EInitialising), PANIC(KHCICmdQPanic, EInvalidStateTransition));

	__ASSERT_ALWAYS((iInitCommandQ.IsEmpty()), PANIC(KHCICmdQPanic, EStartCalledWhenInitQNotEmpty));

	__ASSERT_ALWAYS(iHctl &&

					iCommandAllocator &&

					iLinkMuxer &&

					iUnmatchedEventObserver &&

					iHardResetInitiator, PANIC(KHCICmdQPanic, EObjectNotInitialised));

	iCmdQControllerState = EStarted;

	if(AnyCmdsToSend())

		{

		iAsyncCallBackForSend->CallBack();

		}

	}

/**

Called by CLinkMuxer only when the command sub-channel is open.

This shall be as a result of this class calling MLinkMuxNotifier::TryToSend.

Only one send should be sent during this function. If another command is suitable

for sending then MLinkMuxNotifier::TryToSend should be called again to get 

permission to do the sending.

*/

EXPORT_C void CHCICmdQController::DoSend()

	{

	LOG_FUNC;

	LOG1(_L("CHCICmdQController::DoSend() - iSendingCommand = 0x%08x"), iSendingCommand);

	if(iSendingCommand)

		{

		// Format and send the command frame.  Operation cannot fail.

		iSendingCommand->FormatFrame();

		TInt err = iHctl->MhiWriteCommand(iSendingCommand->Frame().HCTLPayload());

		LOG1(_L("CHCICmdQController::DoSend() - MhiWriteCommand, Err = %d"), err);

		if(err == KErrNone)

			{

			// Increment the commands sent count.

			iSendingCommand->CommandSent();

			TUint consumed = iSendingCommand->Command().CreditsConsumed();

			// Check if the vendor command has a completion event

			MHCICompletingEventQuery* completingEventInterface = NULL;

			err = iSendingCommand->Command().Extension_(KCompletingEventExpectUid, reinterpret_cast<TAny*&>(completingEventInterface), NULL);

			if( (err == KErrNone && !completingEventInterface->MhceqCompletingEventExpected()) ||

				{

				// Certain commands (e.g. the Number of Host Complete Packets

				// command) use no credits and do not normally return any

				// event. In this case the command is not moved to the sent

				// queue to prevent it from continually growing.

				// This call will set iSendingCommand to NULL.

				DeleteCommand(iSendingCommand);

				}

			else

				{

				// Decrement command credits, move the command to the sent queue and clear the send buffer.

				__ASSERT_ALWAYS((consumed <= iCommandCredits),

							    PANIC(KHCICmdQPanic, ECommandCreditsCountLessThanZero));

				LOG2(_L("CHCICmdQController::DoSend() - iCommandCredits = %d,  consumed = %d"), iCommandCredits, consumed);

				// If necessary start completion timer.

				TUint timeout(iQdp->MhcqdiTimeoutRequired(*iSendingCommand));

				__ASSERT_ALWAYS((timeout <= MhcqMaxHciCommandTimeout()),

								PANIC(KHCICmdQPanic, ECommandTimeoutTooBig));

				// If a timeout has been specified from the QDP start it.

				if(timeout != MHCICmdQueueDecisionInterface::KNoTimeoutRequired)

					{

					iSendingCommand->StartCompletionTimer(timeout, *this);

					}

				iCommandCredits -= consumed;

				iSentCommandQ.AddLast(*iSendingCommand);

				iSendingCommand = NULL;

				}

			}

		else

			{

			// Failed to write the command.  Error the client.

			if(iSendingCommand->Client())

				{

				iSendingCommand->Client()->MhcqcCommandErrored(err, &iSendingCommand->Command());

				}

			DeleteCommand(iSendingCommand); // This will also NULL iSendingCommand

			}

		}

	// Clear the TryToSendBlock and reschedule if required.

	ClearBlock(ETryToSendBlock);

	if(AnyCmdsToSend())

		{

		iAsyncCallBackForSend->CallBack();

		}

	}

/**

This function is called when the timer for aUncompletedCmdId fires.

@panic ETimedOutCommandError if aUncompletedCmdId does not exist on

the sent queue.

@param aUncompletedCmdId the ID of the uncompleted command.

*/

void CHCICmdQController::CompletionTimeoutFired(TUint aUncompletedCmdId)

	{

	LOG_FUNC

	CHCICommandQItem* cmd = ScanQueueByQId(iSentCommandQ, aUncompletedCmdId);

	__ASSERT_ALWAYS(cmd != NULL, PANIC(KHCICmdQPanic, ETimedOutCommandError));

	ProcessCommandCompletionTimeout(cmd);

	if (AnyCmdsToSend())

		{

		iAsyncCallBackForSend->CallBack();

		}

	}

/**

@panic ECanSendDeadlock as a guard against a CanSend block deadlock in

	   UDEB builds. In UREL builds,

	   MHardResetInitiator::MhriStartHardReset will be called.

@panic EResendDeadlock as a guard against a Resend block deadlock in

	   UDEB builds. In UREL builds,

	   MHardResetInitiator::MhriStartHardReset will be called.

@panic EUnknownDeadlock as a guard against priority queue deadlock in

	   UDEB builds, i.e. the priority queue hasn't changed at all.

	   In UREL builds, MHardResetInitiator::MhriStartHardReset will be called.

@param aNextPendingCmdId this was the ID of the next pending

	   command when the timer was started. If this hasn't changed then

	   panic / ResetCycle as above.

*/

void CHCICmdQController::StarvationTimeoutFired(TUint __DEBUG_ONLY(aNextPendingCmdId))

	{

	LOG_FUNC

#ifdef _DEBUG

	// Check for possible dead-lock situation that can occur.

	TDblQue<CHCICommandQItem>* queue = QueueSendingNext();

	if (queue)

		{

		if (queue != &iPriorityCommandQ)

			{

			CHCICommandQItem* cmd = queue->First();

			if (cmd->CommandQId() == aNextPendingCmdId)

				{

				if (Blocked(ECanSendBlock, ENoBlocks))

					{

					PANIC(KHCICmdQPanic, ECanSendDeadlock);

					}

				else if (Blocked(EResendBlock, ENoBlocks))

					{

					PANIC(KHCICmdQPanic, EResendDeadlock);

					}

				}

			}

		else if (aNextPendingCmdId == KInvalidCommandQueueItemId)

			{

			// This is priority queue, so we can't point to a single culprit.

			// Apparently none of the commands on the queue could be sent.

			PANIC(KHCICmdQPanic, EUnknownDeadlock);

			}

		}

	// Always assert in debug builds for starvation timer conditions.

	// This may be removed when more is known about these scenarios.

	__ASSERT_DEBUG(EFalse, PANIC(KHCICmdQPanic, EStarvationTimerFired));

#endif

	// Force possibly stale caching blocks to be recomputed.

	ClearBlock(ECachingCommandBlocks);

	iHardResetInitiator->MhriStartHardReset();

	}

/** 

Virtuals from MHCICommandQueue

*/

/*virtual*/ TUint CHCICmdQController::MhcqAddCommandL(CHCICommandQItem* aQueItem)

	{

	LOG_FUNC	

	__ASSERT_ALWAYS(aQueItem != NULL, PANIC(KHCICmdQPanic, EAttemptToAddNullCommand));

	return DoAddCommandL(*aQueItem, iNormalCommandQ, EStarted);

	}

/*virtual*/ TUint CHCICmdQController::MhcqAddCommandL(CHCICommandBase* aCommandData, MHCICommandQueueClient& aCmdProgressRecipient)

	{

	LOG_FUNC

	__ASSERT_ALWAYS(aCommandData != NULL, PANIC(KHCICmdQPanic, EAttemptToAddNullCommand));

	__ASSERT_ALWAYS(iCommandAllocator != NULL, PANIC(KHCICmdQPanic, EObjectNotInitialised));

	CHCICommandQItem* aQueItem = CHCICommandQItem::NewL(*iCommandAllocator, 

														aCmdProgressRecipient, 

														aCommandData);

	return MhcqAddCommandL(aQueItem);

	}

/*virtual*/ TUint CHCICmdQController::MhcqAddPriorityCommandL(CHCICommandQItem* aQueItem)

	{

	LOG_FUNC

	__ASSERT_ALWAYS(aQueItem != NULL, PANIC(KHCICmdQPanic, EAttemptToAddNullCommand));

	return DoAddCommandL(*aQueItem, iPriorityCommandQ, EStarted);

	}

/*virtual*/ TUint CHCICmdQController::MhcqAddPriorityCommandL(CHCICommandBase* aCommandData, MHCICommandQueueClient& aCmdProgressRecipient)

	{

	LOG_FUNC

	__ASSERT_ALWAYS(aCommandData != NULL, PANIC(KHCICmdQPanic, EAttemptToAddNullCommand));

	__ASSERT_ALWAYS(iCommandAllocator != NULL, PANIC(KHCICmdQPanic, EObjectNotInitialised));

	CHCICommandQItem* aQueItem = CHCICommandQItem::NewL(*iCommandAllocator, 

														aCmdProgressRecipient, 

														aCommandData);

	return MhcqAddPriorityCommandL(aQueItem);

	}

/*virtual*/ TUint CHCICmdQController::MhcqAddInitCommandL(CHCICommandQItem* aQueItem)

	{

	LOG_FUNC

	__ASSERT_ALWAYS(aQueItem != NULL, PANIC(KHCICmdQPanic, EAttemptToAddNullCommand));

	__ASSERT_ALWAYS((iCmdQControllerState != EStarted), PANIC(KHCICmdQPanic, EInitCmdAfterStart));

	TUint ret = DoAddCommandL(*aQueItem, iInitCommandQ, EInitialising);

	// Mark as an Initialisation command.

	aQueItem->SetInitialisationCmd();

	return ret;

	}

/*virtual*/ TUint CHCICmdQController::MhcqAddInitCommandL(CHCICommandBase* aCommandData, MHCICommandQueueClient& aCmdProgressRecipient)

	{

	LOG_FUNC

	__ASSERT_ALWAYS(aCommandData != NULL, PANIC(KHCICmdQPanic, EAttemptToAddNullCommand));

	__ASSERT_ALWAYS(iCommandAllocator != NULL, PANIC(KHCICmdQPanic, EObjectNotInitialised));

	CHCICommandQItem* aQueItem = CHCICommandQItem::NewL(*iCommandAllocator, 

														aCmdProgressRecipient, 

														aCommandData);

	return MhcqAddInitCommandL(aQueItem);

	}

/*virtual*/ TInt CHCICmdQController::MhcqRemoveCommand(TUint aCommandId,

													   const MHCICommandQueueClient& aCmdOriginator)

	{

	LOG_FUNC