1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 /**

    17  @file

    18  @internalComponent

    19 */

    20 

    21 #include <bluetooth/hcicmdqcontroller.h>

    22 #include <bluetooth/hci/hciconsts.h>

    23 

    24 #include "HciCmdQTimer.h"

    25 #include "HciCmdQUtil.h"

    26 

    27 #include <bluetooth/hardresetinitiator.h>

    28 #include <bluetooth/hcicommandqitem.h>

    29 #include <bluetooth/hcicommandqueueclient.h>

    30 #include <bluetooth/linkmuxnotifier.h>

    31 #include <bluetooth/hci/commandstatusevent.h>

    32 #include <bluetooth/hci/event.h>

    33 #include <bluetooth/hci/commandcompleteevent.h>

    34 #include <bluetooth/hci/hcicmdqueuedecisionplugin.h>

    35 #include <bluetooth/hci/hcicmdqueuedecisioninterface.h>

    36 #include <bluetooth/hci/hciframe.h>

    37 #include <bluetooth/hci/hctlinterface.h>

    38 #include <bluetooth/hci/hciutil.h>

    39 #include <bluetooth/hci/command.h>

    40 #include <bluetooth/hci/hcievents.h>

    41 #include <bluetooth/hci/completingeventquery.h>

    42 

    43 #include <bluetooth/logger.h>

    44 

    45 #ifdef __FLOG_ACTIVE

    46 _LIT8(KLogComponent, LOG_COMPONENT_HCICMDQ);

    47 #endif

    48 

    49 #ifdef _DEBUG

    50 PANICCATEGORY("hcicmdqcon");

    51 #endif

    52 

    53 _LIT(KHciCommandQueueComponentName, "cmdq");

    54 

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

    56 	{

    57 	MhcquiInjectEvent(aEvent);

    58 	}

    59 

    60 EXPORT_C CHCICommandQItem* MHCICmdQueueUtilities::FindOutstandingCommand(THCIOpcode aOpcode)

    61 	{

    62 	return MhcquiFindOutstandingCommand(aOpcode);

    63 	}

    64 

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

    66 	{

    67 	LOG_STATIC_FUNC

    68 

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

    70 	CleanupStack::PushL(self);

    71 	self->ConstructL();

    72 	CleanupStack::Pop(self);

    73 	return self;

    74 	}

    75 

    76 /**

    77 Destructor.

    78 */

    79 EXPORT_C CHCICmdQController::~CHCICmdQController()

    80 	{

    81 	LOG_FUNC

    82 

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

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

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

    86 	if(!iInitCommandQ.IsEmpty())

    87 		{

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

    89 		LogQueue(iInitCommandQ);

    90 		}

    91 	if(!iNormalCommandQ.IsEmpty())

    92 		{

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

    94 		LogQueue(iNormalCommandQ);

    95 		}

    96 	if(!iPriorityCommandQ.IsEmpty())

    97 		{

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

    99 		LogQueue(iPriorityCommandQ);

   100 		}

   101 	if(!iWorkaroundCommandQ.IsEmpty())

   102 		{

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

   104 		LogQueue(iWorkaroundCommandQ);

   105 		}

   106 #endif // _DEBUG && __FLOG_ACTIVE

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

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

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

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

   111 	

   112 	// Clean up internally managed queues

   113 	TDblQueIter<CHCICommandQItem> sentIter(iSentCommandQ);

   114 	CleanUpQueue(sentIter);

   115 	TDblQueIter<CHCICommandQItem> resendIter(iResendCommandQ);

   116 	CleanUpQueue(resendIter);

   117 

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

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

   120 		

   121 	delete iQStarvationTimer;

   122 	delete iSendingCommand;

   123 	delete iQdpPlugin;

   124 

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

   126 	// d'tor of CAsyncOneShot.

   127 	delete iAsyncCallBackForReset;

   128 	delete iAsyncCallBackForSend;

   129 

   130 	delete iHciUtil;

   131 	CLOSE_LOGGER

   132 	}

   133 

   134 /**

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

   136 send command frames over the HCTL.

   137 

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

   139 */

   140 EXPORT_C void CHCICmdQController::SetHCTLInterface(MHCTLInterface& aHctlInterface)

   141 	{

   142 	LOG_FUNC

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

   144 	iHctl = &aHctlInterface;

   145 	}

   146 

   147 /**

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

   149 Controller to create HCI command frames.

   150 

   151 @param aCommandAllocator Implementation of command allocator interface.

   152 */

   153 EXPORT_C void CHCICmdQController::SetHCICommandAllocator(MHCICommandAllocator& aCommandAllocator)

   154 	{

   155 	LOG_FUNC

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

   157 	iCommandAllocator = &aCommandAllocator;

   158 	}

   159 

   160 /**

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

   162 Controller to provide co-ordinated sending to the HCTL.

   163 

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

   165 */

   166 EXPORT_C void CHCICmdQController::SetLinkMuxNotifier(MLinkMuxNotifier& aLinkMuxer)

   167 	{

   168 	LOG_FUNC

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

   170 	iLinkMuxer = &aLinkMuxer;

   171 	}

   172 

   173 /**

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

   175 	

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

   177 */

   178 EXPORT_C void CHCICmdQController::SetHCIUnmatchedEventObserver(MHCICommandQueueClient& aUnmatchedEventObserver)

   179 	{

   180 	LOG_FUNC

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

   182 	iUnmatchedEventObserver = &aUnmatchedEventObserver;

   183 	}

   184 

   185 /**

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

   187 This will allow the QDP to request a Hard Reset.

   188 

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

   190 */

   191 EXPORT_C void CHCICmdQController::SetHardResetInitiator(MHardResetInitiator& aHardResetInitiator)

   192 	{

   193 	LOG_FUNC

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

   195 	iHardResetInitiator = &aHardResetInitiator;

   196 	iQdp->MhcqdiSetHardResetInitiator(aHardResetInitiator);

   197 	}

   198 

   199 /**

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

   201 physical links in the stack..

   202 

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

   204 */

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

   206 	{

   207 	LOG_FUNC

   208 	iQdp->MhcqdiSetPhysicalLinksState(aStackInfo);

   209 	}

   210 

   211 /**

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

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

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

   215 when we transition to the Started state.

   216 @see CHCICmdQController::Start

   217 */

   218 EXPORT_C void CHCICmdQController::Initialise()

   219 	{

   220 	LOG_FUNC

   221 	

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

   223 	// state or the Resetting state

   224 	switch(iCmdQControllerState)

   225 		{

   226 		case EUninitialised:

   227 			iCmdQControllerState = EInitialising;

   228 			break;

   229 			

   230 		case EResetting:

   231 			iCmdQControllerState = EResetInit;

   232 			break;

   233 		

   234 		default:

   235 			PANIC(KHCICmdQPanic, EInvalidStateTransition);

   236 			break;

   237 		};

   238 	}

   239 	

   240 /**

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

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

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

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

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

   246 called.

   247 @see CHCICmdQController::Initialise

   248 */

   249 EXPORT_C void CHCICmdQController::Reset()

   250 	{

   251 	LOG_FUNC

   252 	

   253 	// Mark the tails of the queues.

   254 	StorePurgeMarks();

   255 	

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

   257 	iQStarvationTimer->Cancel();

   258 

   259 	iCmdQControllerState = EResetting;

   260 

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

   262 	iAsyncCallBackForSend->Cancel();

   263 	

   264 	// Call async CallBack to initiate Reset processing.

   265 	iAsyncCallBackForReset->CallBack();

   266 	}

   267 

   268 /**

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

   270 safe to send normal (non-initialisation) commands.

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

   272 @see CHCICmdQController::Reset

   273 @panic EInvalidStateTransition if not in the initialising state.

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

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

   276 */

   277 EXPORT_C void CHCICmdQController::Start()

   278 	{

   279 	LOG_FUNC

   280 

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

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

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

   284 	__ASSERT_ALWAYS(iHctl &&

   285 					iCommandAllocator &&

   286 					iLinkMuxer &&

   287 					iUnmatchedEventObserver &&

   288 					iHardResetInitiator, PANIC(KHCICmdQPanic, EObjectNotInitialised));

   289 

   290 	iCmdQControllerState = EStarted;

   291 	if(AnyCmdsToSend())

   292 		{

   293 		iAsyncCallBackForSend->CallBack();

   294 		}

   295 	}

   296 

   297 /**

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

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

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

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

   302 permission to do the sending.

   303 */

   304 EXPORT_C void CHCICmdQController::DoSend()

   305 	{

   306 	LOG_FUNC;

   307 

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

   309 

   310 	if(iSendingCommand)

   311 		{

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

   313 		iSendingCommand->FormatFrame();

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

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

   316 

   317 		if(err == KErrNone)

   318 			{

   319 			// Increment the commands sent count.

   320 			iSendingCommand->CommandSent();

   321 

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

   323 			// Check if the vendor command has a completion event

   324 			MHCICompletingEventQuery* completingEventInterface = NULL;

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

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

   327 				(err == KErrNotSupported && consumed == 0))

   328 				{

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

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

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

   332 				// queue to prevent it from continually growing.

   333 				// This call will set iSendingCommand to NULL.

   334 				DeleteCommand(iSendingCommand);

   335 				}

   336 			else

   337 				{

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

   339 				__ASSERT_ALWAYS((consumed <= iCommandCredits),

   340 							    PANIC(KHCICmdQPanic, ECommandCreditsCountLessThanZero));

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

   342 

   343 				// If necessary start completion timer.

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

   345 				__ASSERT_ALWAYS((timeout <= MhcqMaxHciCommandTimeout()),

   346 								PANIC(KHCICmdQPanic, ECommandTimeoutTooBig));

   347 

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

   349 				if(timeout != MHCICmdQueueDecisionInterface::KNoTimeoutRequired)

   350 					{

   351 					iSendingCommand->StartCompletionTimer(timeout, *this);

   352 					}

   353 				

   354 				iCommandCredits -= consumed;

   355 				iSentCommandQ.AddLast(*iSendingCommand);

   356 				iSendingCommand = NULL;

   357 				}

   358 			}

   359 		else

   360 			{

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

   362 			if(iSendingCommand->Client())

   363 				{

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

   365 				}

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

   367 			}

   368 		}

   369 	// Clear the TryToSendBlock and reschedule if required.

   370 	ClearBlock(ETryToSendBlock);

   371 	if(AnyCmdsToSend())

   372 		{

   373 		iAsyncCallBackForSend->CallBack();

   374 		}

   375 	}

   376 

   377 /**

   378 This function is called when the timer for aUncompletedCmdId fires.

   379 @panic ETimedOutCommandError if aUncompletedCmdId does not exist on

   380 the sent queue.

   381 @param aUncompletedCmdId the ID of the uncompleted command.

   382 */

   383 void CHCICmdQController::CompletionTimeoutFired(TUint aUncompletedCmdId)

   384 	{

   385 	LOG_FUNC

   386 	

   387 	CHCICommandQItem* cmd = ScanQueueByQId(iSentCommandQ, aUncompletedCmdId);

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

   389 	

   390 	ProcessCommandCompletionTimeout(cmd);

   391  

   392 	if (AnyCmdsToSend())

   393 		{

   394 		iAsyncCallBackForSend->CallBack();

   395 		}

   396 	}

   397 

   398 /**

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

   400 	   UDEB builds. In UREL builds,

   401 	   MHardResetInitiator::MhriStartHardReset will be called.

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

   403 	   UDEB builds. In UREL builds,

   404 	   MHardResetInitiator::MhriStartHardReset will be called.

   405 @panic EUnknownDeadlock as a guard against priority queue deadlock in

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

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

   408 @param aNextPendingCmdId this was the ID of the next pending

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

   410 	   panic / ResetCycle as above.

   411 */

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

   413 	{

   414 	LOG_FUNC

   415 

   416 #ifdef _DEBUG

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

   418 	TDblQue<CHCICommandQItem>* queue = QueueSendingNext();

   419 	

   420 	if (queue)

   421 		{

   422 		if (queue != &iPriorityCommandQ)

   423 			{

   424 			CHCICommandQItem* cmd = queue->First();

   425 	

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

   427 				{

   428 				if (Blocked(ECanSendBlock, ENoBlocks))

   429 					{

   430 					PANIC(KHCICmdQPanic, ECanSendDeadlock);

   431 					}

   432 				else if (Blocked(EResendBlock, ENoBlocks))

   433 					{

   434 					PANIC(KHCICmdQPanic, EResendDeadlock);

   435 					}

   436 				}

   437 			}

   438 		else if (aNextPendingCmdId == KInvalidCommandQueueItemId)

   439 			{

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

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

   442 			PANIC(KHCICmdQPanic, EUnknownDeadlock);

   443 			}

   444 		}

   445 	

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

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

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

   449 #endif

   450 

   451 	// Force possibly stale caching blocks to be recomputed.

   452 	ClearBlock(ECachingCommandBlocks);

   453 	

   454 	iHardResetInitiator->MhriStartHardReset();

   455 	}

   456 

   457 /** 

   458 Virtuals from MHCICommandQueue

   459 */

   460 

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

   462 	{

   463 	LOG_FUNC	

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

   465 

   466 	return DoAddCommandL(*aQueItem, iNormalCommandQ, EStarted);

   467 	}

   468 

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

   470 	{

   471 	LOG_FUNC

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

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

   474 

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

   476 														aCmdProgressRecipient, 

   477 														aCommandData);

   478 	return MhcqAddCommandL(aQueItem);

   479 	}

   480 

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

   482 	{

   483 	LOG_FUNC

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

   485 

   486 	return DoAddCommandL(*aQueItem, iPriorityCommandQ, EStarted);

   487 	}

   488 

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

   490 	{

   491 	LOG_FUNC

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

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

   494 	

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

   496 														aCmdProgressRecipient, 

   497 														aCommandData);

   498 	return MhcqAddPriorityCommandL(aQueItem);

   499 	}

   500 

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

   502 	{

   503 	LOG_FUNC

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

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

   506 

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

   508 	// Mark as an Initialisation command.

   509 	aQueItem->SetInitialisationCmd();

   510 	return ret;

   511 	}

   512 

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

   514 	{

   515 	LOG_FUNC

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

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

   518 

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

   520 														aCmdProgressRecipient, 

   521 														aCommandData);

   522 	return MhcqAddInitCommandL(aQueItem);

   523 	}

   524 

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

   526 													   const MHCICommandQueueClient& aCmdOriginator)

   527 	{

   528 	LOG_FUNC

   529 

   530 	CHCICommandQItem* pendingCmd = NULL;

   531 	CHCICommandQItem* lockedCmd = NULL;

   532 	TInt retVal = KErrNotFound;

   533 	

   534 	pendingCmd = ScanQueueByQId(iNormalCommandQ, aCommandId);

   535 	if(!pendingCmd)

   536 		{

   537 		pendingCmd = ScanQueueByQId(iInitCommandQ, aCommandId);

   538 		if (!pendingCmd)

   539 			{

   540 			pendingCmd = ScanQueueByQId(iPriorityCommandQ, aCommandId);

   541 			if (!pendingCmd)

   542 				{

   543 				pendingCmd = ScanQueueByQId(iWorkaroundCommandQ, aCommandId);

   544 				if(!pendingCmd)

   545 					{

   546 					lockedCmd = ScanQueueByQId(iSentCommandQ, aCommandId);

   547 					if(!lockedCmd)

   548 						{

   549 						lockedCmd = ScanQueueByQId(iResendCommandQ, aCommandId);

   550 						}

   551 					}

   552 				}

   553 			}

   554 		}

   555 	

   556 	if(lockedCmd)

   557 		{

   558 		__ASSERT_ALWAYS(lockedCmd->Client() == &aCmdOriginator, PANIC(KHCICmdQPanic, ETryingToDeleteCommandNotOwned));

   559 		retVal = KErrLocked;

   560 		}

   561 	else if(pendingCmd && pendingCmd->IsParent())

   562 		{

   563 		__ASSERT_ALWAYS(pendingCmd->Client() == &aCmdOriginator, PANIC(KHCICmdQPanic, ETryingToDeleteCommandNotOwned));

   564 		retVal = KErrLocked;

   565 		}

   566 	else if(pendingCmd)

   567 		{

   568 		__ASSERT_ALWAYS(pendingCmd->Client() == &aCmdOriginator, PANIC(KHCICmdQPanic, ETryingToDeleteCommandNotOwned));

   569 		__ASSERT_ALWAYS(!pendingCmd->IsPreChild(), PANIC(KHCICmdQPanic, ETryingToDeletePreChildCommandById));

   570 		__ASSERT_ALWAYS(!pendingCmd->IsPostChild(), PANIC(KHCICmdQPanic, ETryingToDeletePostChildCommandById));		

   571 		DeleteCommand(pendingCmd);

   572 		retVal = KErrNone;

   573 		}

   574 

   575 	return retVal;

   576 	}

   577 

   578 void CHCICmdQController::HandleCommandRemoval(CHCICommandQItem*& aCmd, TBool aCanDelete)

   579 	{

   580 	LOG_FUNC

   581 	ASSERT_DEBUG(aCmd);

   582 	if(aCanDelete && !aCmd->IsParent())

   583 		{

   584 		// The client should never be the originator of child commands

   585 		__ASSERT_ALWAYS(!aCmd->IsPreChild(), PANIC(KHCICmdQPanic, ETryingToDeletePreChildCommand));

   586 		__ASSERT_ALWAYS(!aCmd->IsPostChild(), PANIC(KHCICmdQPanic, ETryingToDeletePostChildCommand));

   587 		DeleteCommand(aCmd);

   588 		}

   589 	else

   590 		{

   591 		aCmd->DetachClient();

   592 		}

   593 	}

   594 

   595 void CHCICmdQController::HandleCommandRemoval(CHCICommandQItem& aCmd, TBool aCanDelete)

   596 	{

   597 	LOG_FUNC

   598 	CHCICommandQItem* cmd = &aCmd;

   599 	HandleCommandRemoval(cmd, aCanDelete);

   600 	}

   601 

   602 void CHCICmdQController::RemoveAllCommands(TDblQueIter<CHCICommandQItem> aIter,

   603 											const MHCICommandQueueClient& aCmdOriginator,

   604 											TBool aCanDelete)

   605 	{

   606 	LOG_FUNC

   607 	

   608 	for (CHCICommandQItem* item(aIter++);item != NULL;item = aIter++)

   609 		{

   610 		if(item->Client() == &aCmdOriginator)

   611 			{

   612 			HandleCommandRemoval(*item, aCanDelete);

   613 			}

   614 		}

   615 	}

   616 

   617 /*virtual*/ void  CHCICmdQController::MhcqRemoveAllCommands(const MHCICommandQueueClient& aCmdOriginator)

   618 	{

   619 	LOG_FUNC

   620 

   621 	TDblQueIter<CHCICommandQItem> initIter(iInitCommandQ);

   622 	RemoveAllCommands(initIter, aCmdOriginator, ETrue);

   623 

   624 	TDblQueIter<CHCICommandQItem> normalIter(iNormalCommandQ);

   625 	RemoveAllCommands(normalIter, aCmdOriginator, ETrue);

   626 

   627 	TDblQueIter<CHCICommandQItem> priorityIter(iPriorityCommandQ);

   628 	RemoveAllCommands(priorityIter, aCmdOriginator, ETrue);

   629 

   630 	TDblQueIter<CHCICommandQItem> workaroundIter(iWorkaroundCommandQ);

   631 	RemoveAllCommands(workaroundIter, aCmdOriginator, ETrue);

   632 

   633 	TDblQueIter<CHCICommandQItem> sentIter(iSentCommandQ);

   634 	RemoveAllCommands(sentIter, aCmdOriginator, EFalse);

   635 

   636 	TDblQueIter<CHCICommandQItem> resendIter(iResendCommandQ);

   637 	RemoveAllCommands(resendIter, aCmdOriginator, EFalse);

   638 

   639 	if(iSendingCommand)

   640 		{

   641 		if(iSendingCommand->Client() == &aCmdOriginator)

   642 			{

   643 			HandleCommandRemoval(iSendingCommand, ETrue);

   644 			}

   645 		}

   646 	}

   647 

   648 void CHCICmdQController::CleanUpQueue(TDblQueIter<CHCICommandQItem> aIter)

   649 	{

   650 	LOG_FUNC

   651 	

   652 	for (CHCICommandQItem* item(aIter++);item != NULL;item = aIter++)

   653 		{

   654 		DeleteCommand(item);

   655 		}

   656 	}

   657 

   658 /*virtual*/ TUint CHCICmdQController::MhcqMaxHciCommandTimeout() const

   659 	{

   660 	LOG_FUNC

   661 	

   662 	return iMaxHciCommandTimeout;

   663 	}

   664 

   665 /*virtual*/ TAny* CHCICmdQController::MhcqQdpPluginInterface(TUid aUid) const

   666 	{

   667 	LOG_FUNC

   668 

   669 	__ASSERT_ALWAYS((aUid != TUid::Uid(KHCICmdQueueDecisionInterfaceUid))

   670 					&& (aUid != TUid::Uid(KHCICmdQueueDecisionEventModifierInterfaceUid)),

   671 					PANIC(KHCICmdQPanic, EIllegalRequestForQdpInterface));

   672 	return (iQdpPlugin) ? iQdpPlugin->Interface(aUid) : NULL;

   673 	}

   674 

   675 /** 

   676 Virtuals from MHCICommandEventObserver

   677 */

   678 

   679 /*virtual*/ void CHCICmdQController::MhceoEventNotification(const THCIEventBase& aEvent)

   680 	{

   681 	LOG_FUNC

   682 	

   683 	ProcessEvent(aEvent, ETrue);

   684 	}

   685 

   686 void CHCICmdQController::ProcessEvent(const THCIEventBase& aEvent, TBool aSendToQdp)

   687 	{

   688 	LOG_FUNC

   689 	

   690 	// Process command credits.

   691 	THCIEventCode eventCode(aEvent.EventCode());

   692 	if (eventCode == ECommandCompleteEvent)

   693 		{

   694 

   695 		const THCICommandCompleteEvent& event(THCICommandCompleteEvent::Cast(aEvent));

   696 		UpdateCommandCredits(event.NumHCICommandPackets());

   697 

   698 		if (event.CommandOpcode() == KNopOpcode)

   699 			{

   700 			// This is a special command complete event that does not

   701 			// complete an event. Command_Opcode, 0x0000 is a NOP, and

   702 			// can be used to change the number of outstanding HCI

   703 			// command packets that the Host can send before waiting.

   704 

   705 			// Nothing else to do for this event, so throw it away

   706 			return;

   707 			}

   708 		}

   709 	else if (eventCode == ECommandStatusEvent)

   710 		{

   711 		TCommandStatusEvent& event = TCommandStatusEvent::Cast(aEvent);

   712 		UpdateCommandCredits(event.NumHCICommandPackets());

   713 

   714 		if (event.CommandOpcode() == KNopOpcode)

   715 			{

   716 			// Same as above for NOP command complete event.

   717 			

   718 			// Nothing else to do for this event, so throw it away

   719 			return;

   720 			}

   721 		}

   722 

   723 	// Iterate through sent queue to try and match the event to a sent command.

   724 	CHCICommandQItem* cmd(0);

   725 	TDblQueIter<CHCICommandQItem> qIter(iSentCommandQ);

   726 	TBool matchesCmd(EFalse);

   727 	TBool concludesCmd(EFalse);

   728 	TBool continueMatching(EFalse);

   729 	TBool eventMatched(EFalse);

   730 

   731 	while ((qIter != NULL) && (!eventMatched || continueMatching))

   732 		{

   733 		cmd = qIter++;		

   734 		cmd->Command().Match(aEvent, matchesCmd, concludesCmd, continueMatching);

   735 		if (matchesCmd)

   736 			{

   737 			eventMatched = ETrue;

   738 			

   739 			// If the event concludes the command then remove it from the sent queue

   740 			if (concludesCmd)

   741 				{

   742 				cmd->iLink.Deque();

   743 				}

   744 			

   745 			if (aSendToQdp)

   746 				{

   747 				// Notify QDP.

   748 				if (iQdpEventModifier)

   749 					{

   750 					THCIEventCode origEventCode = aEvent.EventCode();

   751 					iQdpEventModifier->MhcqemiMatchedEventReceived(const_cast<THCIEventBase&>(aEvent), *cmd);

   752 					__ASSERT_ALWAYS(origEventCode == aEvent.EventCode(), PANIC(KHCICmdQPanic, EQdpTryingToChangeEventCode));

   753 					}

   754 				else

   755 					{

   756 					iQdp->MhcqdiMatchedEventReceived(aEvent, *cmd);

   757 					}

   758 				}

   759 		

   760 			// Process the matched event.

   761 			if (aEvent.ErrorCode() == EOK)

   762 				{

   763 				ProcessMatchedEvent(aEvent, cmd, concludesCmd);

   764 				}

   765 			else

   766 				{

   767 				ProcessMatchedErrorEvent(aEvent, cmd, concludesCmd, aSendToQdp);

   768 				}

   769 			}

   770 		}

   771 

   772 	if (!eventMatched)

   773 		{

   774 		// Process the unmatched event.

   775 		ProcessUnmatchedEvent(aEvent, aSendToQdp);

   776 		}

   777 	

   778 	// Reschedule if there are commands queued.

   779 	if (AnyCmdsToSend())

   780 		{

   781 		iAsyncCallBackForSend->CallBack();

   782 		}

   783 

   784 	}

   785 

   786 void CHCICmdQController::MhcquiInjectEvent(const THCIEventBase& aEvent)

   787 	{

   788 	LOG_FUNC

   789 	

   790 	ProcessEvent(aEvent, EFalse);

   791 	}

   792 

   793 CHCICommandQItem* CHCICmdQController::MhcquiFindOutstandingCommand(THCIOpcode aOpcode)

   794 	{

   795 	LOG_FUNC

   796 	

   797 	return ScanQueueByOpcode(iSentCommandQ, aOpcode);

   798 	}

   799 

   800 

   801 /**

   802 Constructor.

   803 */

   804 CHCICmdQController::CHCICmdQController()

   805   : iMaxHciCommandTimeout(KDefaultMaxHciCommandTimeout),

   806 	iQueueStarvationTimeout(2 * iMaxHciCommandTimeout),

   807 	iInitCommandQ(_FOFF(CHCICommandQItem,iLink)),

   808 	iNormalCommandQ(_FOFF(CHCICommandQItem,iLink)),

   809 	iPriorityCommandQ(_FOFF(CHCICommandQItem,iLink)),

   810 	iWorkaroundCommandQ(_FOFF(CHCICommandQItem,iLink)),

   811 	iSentCommandQ(_FOFF(CHCICommandQItem,iLink)),

   812 	iResendCommandQ(_FOFF(CHCICommandQItem,iLink)),

   813 	iCmdQControllerState(EUninitialised),

   814 	iNextCommandQItemId(1)

   815 

   816 	{

   817 	CONNECT_LOGGER

   818 	LOG_FUNC

   819 	}

   820 

   821 void CHCICmdQController::ConstructL()

   822 	{

   823 	LOG_FUNC

   824 

   825 	// Add Async Callbacks

   826 	TCallBack resetCallBack(AsyncCallBackForReset, this);

   827 

   828 	iAsyncCallBackForReset =

   829 		new (ELeave)CAsyncCallBack(resetCallBack, CActive::EPriorityStandard);

   830 

   831 	TCallBack startCallBack(AsyncCallBackForSend, this);

   832 

   833 	iAsyncCallBackForSend =

   834 		new (ELeave)CAsyncCallBack(startCallBack, CActive::EPriorityStandard);

   835 

   836 	iQStarvationTimer = CHCICmdQStarvationTimer::NewL();

   837 

   838 	// Create HCI Utility library

   839 	iHciUtil = CHciUtil::NewL(KHciCommandQueueComponentName);

   840 

   841 	// If we can't open the ini file then this will be treated in the same way

   842 	// as not reading a valid UID from the ini file.

   843 	TRAP_IGNORE(iHciUtil->OpenIniFileL());

   844 	

   845 	_LIT(KSection, "QDP");

   846 	_LIT(KQdpUidTag, "EcomUid");

   847 

   848 	TUid qdpImplUid = TUid::Null();

   849 	TRAPD(err, qdpImplUid = iHciUtil->GetUidFromFileL(KSection, KQdpUidTag));

   850 	

   851 	if (err == KErrNone)

   852 		{

   853 		// Valid UID found, load it

   854 		iQdpPlugin = CHCICmdQueueDecisionPlugin::NewL(qdpImplUid);

   855 		}

   856 	else

   857 		{

   858 		// No UID found in ini file, attempt to load single instance of 

   859 		// implementation

   860 		iQdpPlugin = CHCICmdQueueDecisionPlugin::NewL();

   861 		}

   862 

   863 	iQdp = reinterpret_cast<MHCICmdQueueDecisionInterface*>(iQdpPlugin->Interface(TUid::Uid(KHCICmdQueueDecisionInterfaceUid)));

   864 	iQdpEventModifier = reinterpret_cast<MHCICmdQueueEventModifierInterface*>(iQdpPlugin->Interface(TUid::Uid(KHCICmdQueueDecisionEventModifierInterfaceUid)));

   865 

   866 	MHCICmdQueueUtilityUser* qdpUtilityUser = reinterpret_cast<MHCICmdQueueUtilityUser*>(iQdpPlugin->Interface(TUid::Uid(KHCICmdQueueUtilityUserUid)));

   867 	

   868 	if (qdpUtilityUser)

   869 		{

   870 		qdpUtilityUser->MhcquuSetUtilitiesProvider(*this);

   871 		}

   872 	

   873 	// Read timeout values

   874 	_LIT(KMaxHciCommandTimeoutTag, "MaxHciCommandTimeout");

   875 	_LIT(KQueueStarvationTimeoutTag, "QueueStarvationTimeout");

   876 

   877 	// Don't worry if we cannot read timeouts from file, already initialised

   878 	// to default values

   879 	TRAP_IGNORE(iMaxHciCommandTimeout = iHciUtil->GetValueFromFileL(KSection, KMaxHciCommandTimeoutTag));

   880 	TRAP_IGNORE(iQueueStarvationTimeout = iHciUtil->GetValueFromFileL(KSection, KQueueStarvationTimeoutTag));

   881 	

   882 	__ASSERT_DEBUG(iMaxHciCommandTimeout < iQueueStarvationTimeout, PANIC(KHCICmdQPanic, EQStarvationTimerNotGreaterThanMaxCmdTimer));

   883 	iQdp->MhcqdiSetTimeouts(iQueueStarvationTimeout, iMaxHciCommandTimeout);

   884 	iQdp->MhcqdiSetHCICommandQueue(*this);

   885 

   886 	// Reset the QDP.

   887 	iCommandCredits = iQdp->MhcqdiReset();

   888 	}

   889 

   890 /**

   891 Tests for the specified TQueueStateBits block(s) being set.

   892 */		

   893 inline TBool CHCICmdQController::Blocked(TUint aBlocksToCheck, TUint aBlocksToBypass)

   894 	{

   895 	return Blocked(iCommandQState, aBlocksToCheck, aBlocksToBypass);

   896 	}

   897 

   898 /**

   899 Tests for the specified TQueueStateBits block(s) being set.

   900 */		

   901 inline TBool CHCICmdQController::Blocked(TUint aBlockStatus, TUint aBlocksToCheck, TUint aBlocksToBypass)

   902 	{

   903 	return (aBlockStatus & (ValidBlocks(aBlocksToCheck) & ValidBlocks(~aBlocksToBypass)));

   904 	}

   905 

   906 /**

   907 Clears the specified TQueueStateBits block(s).

   908 */

   909 inline void	CHCICmdQController::ClearBlock(TUint aBlocks)

   910 	{

   911 	__ASSERT_DEBUG(!InvalidBlocks(aBlocks), PANIC(KHCICmdQPanic, EIllegalBlock));

   912 	iCommandQState &= ValidBlocks(~aBlocks);

   913 	}

   914 	

   915 /**

   916 Sets the specified TQueueStateBits block(s).

   917 */

   918 inline void	CHCICmdQController::SetBlock(TUint aBlocks)

   919 	{

   920 	__ASSERT_DEBUG(!InvalidBlocks(aBlocks), PANIC(KHCICmdQPanic, EIllegalBlock));

   921 	iCommandQState |= ValidBlocks(aBlocks);

   922 	}

   923 	

   924 /**

   925 Masks out invalid TQueueStateBits block bit(s).

   926 */

   927 inline TUint CHCICmdQController::ValidBlocks(TUint aBlocks)

   928 	{

   929 	return (aBlocks & EAllBlocks);

   930 	}

   931 	

   932 /**

   933 Masks out valid TQueueStateBits block bit(s).

   934 */

   935 inline TUint CHCICmdQController::InvalidBlocks(TUint aBlocks)

   936 	{

   937 	return (aBlocks & ~EAllBlocks);

   938 	}

   939 

   940 /**

   941 Check for queue block bypass conditions. Currently the only such condition

   942 is to allow a non-credit consuming command (e.g. the Number of Host Complete

   943 Packets command) to bypass the insufficient credits block.

   944 */

   945 inline TUint CHCICmdQController::CmdBypassBlocks(const CHCICommandQItem& aCmd)

   946 	{

   947 	TUint bypassBlocks = ENoBlocks;

   948 	if (aCmd.Command().CreditsConsumed() == 0)

   949 		{

   950 		bypassBlocks |= EInsufficientCreditBlock;

   951 		}

   952 	return bypassBlocks;

   953 	}

   954 	

   955 /**

   956 Updates the command credits counter and maintains the EInsufficientCreditBlock

   957 */

   958 inline void CHCICmdQController::UpdateCommandCredits(TUint8 aCommandCredits)

   959 	{

   960 	iCommandCredits = aCommandCredits;

   961 	

   962 	if (iCommandCredits > 0)

   963 		{

   964 		// We clear block flags when sending priority commands, so there may be some

   965 		// commands blocked on insufficient credits, but the block flag not set

   966 		// anymore. Hence we want to schedule the callback irrespectably of the status

   967 		// of EInsufficientCreditBlock.

   968 		if (AnyCmdsToSend())

   969 			{

   970 			iAsyncCallBackForSend->CallBack();

   971 			}

   972 		ClearBlock(EInsufficientCreditBlock);

   973 		}

   974 	else

   975 		{

   976 		SetBlock(EInsufficientCreditBlock);	

   977 		}

   978 	}

   979 	

   980 /**

   981 Selects the active command queue (iNormalCommandQ or iInitCommandQ) based on

   982 current state.

   983 */

   984 inline TDblQue<CHCICommandQItem>* CHCICmdQController::ActiveRegularQueue()

   985 	{

   986 	if (iCmdQControllerState == EStarted)

   987 		{

   988 		return &iNormalCommandQ;

   989 		}

   990 	else if ((iCmdQControllerState == EResetInit) || (iCmdQControllerState == EInitialising))

   991 		{

   992 		return &iInitCommandQ;

   993 		}

   994 		

   995 	return NULL;

   996 	}

   997 

   998 /**

   999 Returns the pointer to the queue which contains the command that would be scheduled next.

  1000 Does not take the Resend queue into account.

  1001 */

  1002 TDblQue<CHCICommandQItem>* CHCICmdQController::QueueSendingNext()

  1003 	{

  1004 	if (!iWorkaroundCommandQ.IsEmpty())

  1005 		{

  1006 		// Workaround has highest priority (well, second to resend which we don't care about).

  1007 		return &iWorkaroundCommandQ;

  1008 		}

  1009 	else if ((iCmdQControllerState == EStarted) && !iPriorityCommandQ.IsEmpty())

  1010 		{

  1011 		// Priority comes after Workaround, but we look at it only in EStarted.

  1012 		return &iPriorityCommandQ;

  1013 		}

  1014 	else

  1015 		{

  1016 		// Normal or Initialisation or NULL, depending on the state we're in.

  1017 		return ActiveRegularQueue();

  1018 		}

  1019 	}

  1020 

  1021 /**

  1022 Returns the item at the head of the specified queue, or NULL if the queue is empty.

  1023 */	

  1024 inline CHCICommandQItem* CHCICmdQController::FirstQueueItem(TDblQue<CHCICommandQItem>& aQueue)

  1025 	{

  1026 	return (aQueue.IsEmpty() ? NULL : aQueue.First());

  1027 	}

  1028 

  1029 /**

  1030 Returns the item at the tail of the specified queue, or NULL if the queue is empty.

  1031 */	

  1032 inline CHCICommandQItem* CHCICmdQController::LastQueueItem(TDblQue<CHCICommandQItem>& aQueue)

  1033 	{

  1034 	return (aQueue.IsEmpty() ? NULL : aQueue.Last());

  1035 	}

  1036 	

  1037 /**

  1038 Saves the purge marks for the queues that need them. When a reset is performed,

  1039 the queues will be purged up to those marks.

  1040 */

  1041 void CHCICmdQController::StorePurgeMarks()

  1042 	{

  1043 	iInitQPurgeMark	 = LastQueueItem(iInitCommandQ);

  1044 	iNormalQPurgeMark = LastQueueItem(iNormalCommandQ);

  1045 	iPriorityQPurgeMark = LastQueueItem(iPriorityCommandQ);

  1046 	iWorkaroundQPurgeMark = LastQueueItem(iWorkaroundCommandQ);

  1047 	}

  1048 

  1049 /**

  1050 Purge the queues up to previously saved purge marks.

  1051 */

  1052 void CHCICmdQController::PurgeAllQueues()

  1053 	{

  1054 	// Purge the queues to the recorded tail markers.

  1055 	PurgeQueue(iInitCommandQ, iInitQPurgeMark);

  1056 	PurgeQueue(iNormalCommandQ, iNormalQPurgeMark);

  1057 	PurgeQueue(iPriorityCommandQ, iPriorityQPurgeMark);

  1058 	PurgeQueue(iWorkaroundCommandQ, iWorkaroundQPurgeMark);

  1059 	

  1060 	iInitQPurgeMark = iNormalQPurgeMark = iPriorityQPurgeMark = iWorkaroundQPurgeMark = NULL;

  1061 	

  1062 	// Purge the sent and resend queues entirely.

  1063 	PurgeQueue(iSentCommandQ, LastQueueItem(iSentCommandQ));

  1064 	PurgeQueue(iResendCommandQ, LastQueueItem(iResendCommandQ));

  1065 	}

  1066 

  1067 

  1068 /**

  1069 Removes and deletes items from the head of the queue up to and including the marked

  1070 item.

  1071 */	

  1072 void CHCICmdQController::PurgeQueue(TDblQue<CHCICommandQItem>& aQueue,

  1073 									CHCICommandQItem* aMark)

  1074 	{

  1075 	LOG_FUNC

  1076 

  1077 	// A null aMark implies that there are no commands to purge.

  1078 	if(aMark)

  1079 		{

  1080 		TDblQueIter<CHCICommandQItem> qIter(aQueue);

  1081 		TBool found = EFalse;

  1082 

  1083 		// Ensure that the mark is in the queue.

  1084 		while(qIter && !found)

  1085 			{

  1086 			if(aMark == qIter++)

  1087 				{

  1088 				found = ETrue;

  1089 				}

  1090 			}

  1091 

  1092 		// If the mark was found remove comands upto and including

  1093 		// the mark.

  1094 		if(found)

  1095 			{

  1096 			// Reset the queue iterator.

  1097 			qIter.SetToFirst();

  1098 			found = EFalse;

  1099 			CHCICommandQItem* item = NULL;

  1100 

  1101 			while(qIter && !found)

  1102 				{

  1103 				item = qIter++;

  1104 				if(item == aMark)

  1105 					{

  1106 					// Mark found.  Exit the loop after this element has been removed.

  1107 					found = ETrue;

  1108 					}

  1109 				DeleteCommand(item);

  1110 				}

  1111 			}

  1112 		}

  1113 	}

  1114 

  1115 /**

  1116 Returns the first item with the specified opcode which is closest to the head of the 

  1117 specified queue, or NULL if there is no such opcode on the queue.

  1118 */	

  1119 inline CHCICommandQItem* CHCICmdQController::ScanQueueByOpcode(TDblQue<CHCICommandQItem>& aQueue, THCIOpcode aOpcode)

  1120 	{

  1121 	LOG_FUNC

  1122 

  1123 	CHCICommandQItem* item = NULL;		

  1124 	TDblQueIter<CHCICommandQItem> qIter(aQueue);

  1125 	

  1126 	while (((item = qIter) != NULL) && (item->Command().Opcode() != aOpcode))

  1127 		{

  1128 		qIter++;

  1129 		}

  1130 	

  1131 	return item;

  1132 	}

  1133 

  1134 /**