Constructor.

Destructor.

Selects the active command queue (iNormalCommandQ or iInitCommandQ) based on current state.

Tests if there are items queued on any of the queues active in current state.

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

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

Returns ETrue if our current state allows commands to be queued.

Clears the specified TQueueStateBits block(s).

Check for queue block bypass conditions. Currently the only such condition is to allow a non-credit consuming command (e.g. the Number of Host Complete Packets command) to bypass the insufficient credits block.

Tests if there are items queued on the specified queue.

Dequeues and deletes aItem from its queue.

The general command addition routine. Adds aQueItem to aQueue and schedules the command processing loop if current state is equal to aActiveState.

Performs command queue EResetting state processing. EResetting state is reached by a call to CHCICmdQController::Reset() .

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.

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

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. CHCICmdQController::Start

Masks out valid TQueueStateBits block bit(s).

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

Virtuals from MHCICommandEventObserver

Virtuals from MHCICommandQueue

Helper to be called on command addition. Returns ETrue if the command that will be sent next changed after we added a command to aQueue. Ignores the Resend queue.

Returns the next Command Queue Item Id

Evaluates various blocking conditions to determine if the command can be sent. aCmdQItem is passed by reference to pointer as it can be deleted and NULLified in case of error.

Processes timed out commands.

Process matched error events.

Process matched non-error events.

Processes the priority queue. Returns ETrue if the scheduling loop shouldn't process lower priority queues (which is when the queue is non-empty) and EFalse if the loop should go on.

Processes a regular queue - normal or initialization command queue.

Processes the resend queue. Returns ETrue if the scheduling loop shouldn't process lower priority queues (which is when it schedules a command for resend) and EFalse if the loop should go on.

Processes unmatched events.

Processes the workaround queue. Returns ETrue if the scheduling loop shouldn't process lower priority queues (which is when the queue is non-empty) and EFalse if the loop should go on.

Purge the queues up to previously saved purge marks.

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

Returns the pointer to the queue which contains the command that would be scheduled next. Does not take the Resend queue into account.

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. CHCICmdQController::Initialise

Returns the first item with the specified opcode which is closest to the head of the specified queue, or NULL if there is no such opcode on the queue.

Returns the item with the specified command queue ID from the specified queue, or NULL if there is no such command on the queue.

Submits a request to the link muxer for permission to send a command.

Sets the specified TQueueStateBits block(s).

Sets the HCI Command Allocator interface instance to be used by the Command Queue Controller to create HCI command frames.

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

Sets the HCTL interface instance to be used by the Command Queue Controller to send command frames over the HCTL.

Sets the Hard Reset Initiator interface instance to be used by the QDP. This will allow the QDP to request a Hard Reset.

Sets the Link Mux Notifier interface instance to be used by the Command Queue Controller to provide co-ordinated sending to the HCTL.

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

Process workaround related commands, and is invoked every time a workaround completes. As the QDP interface needs to be passed the concluding event of each workaround command, and events are used synchronously and have a limited lifetime, this means workaround handling has to be done at the same time as the event processing.

This processing ensures that the head of the workaround queue contains the next command in the workaround. It also tidies up and deletes commands as necessary. Child commands are deleted once their events have been reported to the QDP. The parent command lives until the end of the workaround.

Saves the purge marks for the queues that need them. When a reset is performed, the queues will be purged up to those marks.

The main queue processing routine. Schedules the next command and asks HCTL to send.

Updates the command credits counter and maintains the EInsufficientCreditBlock

A helper for restarting the Starvation Timer during command addition/sendout. Determines the next command that will be sent and restarts the timer with the ID of that command. Caveat: this always restarts (or cancels, hence Update rather than just Restart in the name) the timer, so use it only when you know that the command that will be sent next has really changed.

Masks out invalid TQueueStateBits block bit(s).

Command queue block bit flags.

Command queue controller state

Async Callbacks

The CHCICmdQController state variable

Number of HCI command packets the queue controller can send to the HCI. This corresponds to the Num_HCI_Command_Packets event parameter. This is decremented whenever a command is sent to the HCTL, and is updated on receipt of Command Status and Command Complete (including NOP) events.

This is a bit mask of the possible TQueueStateBits states

HCI Utility library

The queue of initialisation commands that have not yet been processed.

Recorded tails of the queues for Reset processing.

A counter generating IDs to uniquely identify commands.

The queue of normal commands that have not yet been processed.

Currently processing parent command. This is maintained to simplify priority command processing while a workaround is in progress, and to ensure that the parent's iQdpData is available to the QDP until the workaround completes.

The queue of priority commands that have not yet been processed. Note: it's not FIFO - the order of execution of commands is determined dynamically.

This timer gets reset every time the next command to send changes. If that command stays the same for too long, we probably have a deadlock of some sorts.

The QDP that the Command Queue will use.

The queue of commands that are waiting to be re-sent to the controller.

Currently processing send command. This is maintained to ensure both that the correct command is processed by DoSend, and that there is only ever one outstanding call to MLinkMuxNotifier::TryToSend at any given time

The queue of commands that have been sent to the controller but have not yet had a response.

The queue of workarounds for commands on the other queues. A command is moved here when time comes to execute it but QDP deems it to be in need of workaround.