// 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 "hcisymbianqdp.h"
#include "hcieventmodifiable.h"
#include <bluetooth/hcicommandqitem.h>
#include <bluetooth/hci/hciopcodes.h>
#include <bluetooth/hci/hciconsts.h>
#include <bluetooth/hci/command.h>
#include <bluetooth/hci/event.h>
#include <bluetooth/hci/commandcompleteevent.h>
#include <bluetooth/hci/disconnectioncompleteevent.h>
#include <bluetooth/hci/readclockoffsetevent.h>
#include <bluetooth/hci/authenticationcompleteevent.h>
#include <bluetooth/hci/readlocalversioninfocompleteevent.h>
#include <bluetooth/hci/writelinkpolicysettingscommand.h>
#include <bluetooth/hci/readlinkpolicysettingscommand.h>
#include <bluetooth/hci/readlmphandlecommand.h>
#include <bluetooth/hci/rolediscoverycommand.h>
#include <bluetooth/hci/sniffsubratingcommand.h>
#include <bluetooth/hci/flushcommand.h>
#include <bluetooth/hci/readautomaticflushtimeoutcommand.h>
#include <bluetooth/hci/writeautomaticflushtimeoutcommand.h>
#include <bluetooth/hci/readtransmitpowerlevelcommand.h>
#include <bluetooth/hci/readlinksupervisiontimeoutcommand.h>
#include <bluetooth/hci/writelinksupervisiontimeoutcommand.h>
#include <bluetooth/hci/readfailedcontactcountercommand.h>
#include <bluetooth/hci/resetfailedcontactcountercommand.h>
#include <bluetooth/hci/readlinkqualitycommand.h>
#include <bluetooth/hci/readrssicommand.h>
#include <bluetooth/hci/readafhchannelmapcommand.h>
#include <bluetooth/hci/readclockcommand.h>

#include <bluetooth/logger.h>

#ifdef __FLOG_ACTIVE
_LIT8(KLogComponent, LOG_COMPONENT_QDP_SYMBIAN);
#endif

#ifdef _DEBUG
PANICCATEGORY("qdpsymbia");
#endif // _DEBUG

void AppendConnectionHandle(TDes8& aDes, THCIConnectionHandle aConnectionHandle)
	{
	LOG_STATIC_FUNC
	THCIConnHandle connHandle = aConnectionHandle.ConnHandle();
	LOG1(_L8("Appending connection handle = 0x%04x"), connHandle);
	TUint8 val[2] = {connHandle & 0xff, connHandle >> 8};
	aDes.Append(val, 2);
	}

/*static*/ CHCISymbianQdp* CHCISymbianQdp::NewL()
	{
	LOG_STATIC_FUNC
	
	CHCISymbianQdp* self = new (ELeave) CHCISymbianQdp();
	return self;
	}

// Private constructor.
CHCISymbianQdp::CHCISymbianQdp()
	{
	LOG_FUNC
	}

TAny* CHCISymbianQdp::Interface(TUid aUid)
	{
	TAny* ret = NULL;
	
	switch(aUid.iUid)
		{
		case KHCICmdQueueDecisionInterfaceUid:
			ret = reinterpret_cast<TAny*>(static_cast<MHCICmdQueueDecisionInterface*>(this));
			break;
		case KHCICmdQueueDecisionEventModifierInterfaceUid:
			ret = reinterpret_cast<TAny*>(static_cast<MHCICmdQueueEventModifierInterface*>(this));
			break;
		case KHCICmdQueueUtilityUserUid:
			ret = reinterpret_cast<TAny*>(static_cast<MHCICmdQueueUtilityUser*>(this));
			break;
		default:
			break;
		};

	return ret;
	}

// MHCICmdQueueDecisionInterface
TBool CHCISymbianQdp::MhcqdiDoesCommandRequireWorkaround(const CHCICommandQItem& /* aParent */)
	{
	LOG_FUNC
	
	// No Workarounds required.
	return EFalse;
	}
	
CHCICommandQItem* CHCISymbianQdp::MhcqdiGetPreChildCommand(const CHCICommandQItem& /* aParent */, 
														   const CHCICommandQItem* /* aPreviousWorkaroundCmd */,
														   const THCIEventBase* /*aPreviousCmdResult*/)
	{
	LOG_FUNC
	
	// No Workarounds required (see MhcqdiDoesCommandRequireWorkaround), should never be called.
	return NULL;
	}

CHCICommandQItem* CHCISymbianQdp::MhcqdiGetPostChildCommand(const CHCICommandQItem& /* aParent */, 
															const CHCICommandQItem* /* aPreviousPostChild */, 
															const THCIEventBase* /*aPreviousCmdResult*/)
	{
	LOG_FUNC
	
	// No Workarounds required (see MhcqdiDoesCommandRequireWorkaround), should never be called.
	return NULL;
	}
	
THCIEventBase* CHCISymbianQdp::MhcqdiGetFakedUnsolicitedEvent(const CHCICommandQItem& /*aParent*/,
															  const THCIEventBase* /*aPreviousFakedEvent*/)
	{
	LOG_FUNC
	
	// No Workarounds required (see MhcqdiDoesCommandRequireWorkaround), should never be called.
	return NULL;
	}
	
void CHCISymbianQdp::MhcqdiCommandAboutToBeDeleted(const CHCICommandQItem& /*aDyingCmd*/)
	{
	LOG_FUNC
	
	// Notification function. No need to do anything.
	}
	
TInt CHCISymbianQdp::MhcqdiCanSend(CHCICommandQItem& /*aCommand*/, const TDblQue<const CHCICommandQItem>& aSentCommands)
	{
	LOG_FUNC

#ifdef SERIAL_LOW_POWER_MODE_REQUESTS
	if (!aSentCommands.IsEmpty())
		{
		THCIOpcode opcode = aSentCommands.Last()->Command().Opcode();
		// The following  commands are blocked to avoid ambiguity in matching mode change
		// events.  This ensures they are issued serially to the controller to prevent any confusion.
		// Note: This workaround currently resides in this Symbian QDP, but may require further
		// modification or placement depending on target hardware characteristics. This workaround
		// may not be required for all controllers.
		if(opcode == KHoldModeOpcode
		|| opcode == KSniffModeOpcode
		|| opcode == KExitSniffModeOpcode
		|| opcode == KSwitchRoleOpcode
		|| opcode == KParkModeOpcode
		|| opcode == KExitParkModeOpcode)
			{
			return EBlock;
			}
		}
#endif // SERIAL_LOW_POWER_MODE_REQUESTS
		
	// if no other issue then allow command queue to proceed   
	return EContinue;
	}
	
TUint CHCISymbianQdp::MhcqdiTimeoutRequired(const CHCICommandQItem& /* aCmdAboutToBeSent */)
	{
	LOG_FUNC
	
	// No timeout required.
	return MHCICmdQueueDecisionInterface::KNoTimeoutRequired;
	}
	
void CHCISymbianQdp::MhcqdiMatchedEventReceived(const THCIEventBase& aEvent, const CHCICommandQItem& /*aRelatedCommand*/)
	{
	LOG_FUNC
	
	// Cache the HCI version number of the controller. This allows
	// us to ignore errors from specific versions of controllers
	if(aEvent.EventCode() == ECommandCompleteEvent
	&& THCICommandCompleteEvent::Cast(aEvent).CommandOpcode() == KReadLocalVersionInfoOpcode)
		{
		const TReadLocalVersionInfoCompleteEvent& readLocalVersionCompleteEvent = TReadLocalVersionInfoCompleteEvent::Cast(aEvent);
		iHCIVersion = readLocalVersionCompleteEvent.Version();
		}
	}

void CHCISymbianQdp::MhcqemiMatchedEventReceived(THCIEventBase& aEvent, const CHCICommandQItem& aRelatedCommand)
	{
	LOG_FUNC
	
#ifdef IGNORE_INVALID_HCI_PARAMETER_ERROR_ON_SET_EVENT_MASK_ON_VERSION_1_1
	FixIgnoreInvalidHciParameterErrorOnSetEventMaskOnVersion1_1(aEvent);
#endif // IGNORE_INVALID_HCI_PARAMETER_ERROR_ON_SET_EVENT_MASK_ON_VERSION_1_1
	
#ifdef FAKE_COMPLETION_EVENTS_ON_DISCONNECTION
	FixFakeCompletionEventsOnDisconnection(aEvent);
#endif // FAKE_COMPLETION_EVENTS_ON_DISCONNECTION

#ifdef ADD_CONNECTION_HANDLE_FOR_TRUNCATED_INVALID_CONNECTION_HANDLE_ERROR_EVENTS
	FixAddConnectionHandleForTruncatedInvalidConnectionHandleErrorEvents(aEvent, &aRelatedCommand);
#endif // ADD_CONNECTION_HANDLE_FOR_TRUNCATED_INVALID_CONNECTION_HANDLE_ERROR_EVENTS

	// Don't forget to call the non-modifiable version of this function too
	MhcqdiMatchedEventReceived(aEvent, aRelatedCommand);
	}


MHCICmdQueueDecisionInterface::TCommandErroredAction CHCISymbianQdp::MhcqdiMatchedErrorEventReceived(const THCIEventBase& /*aErrorEvent*/, 
																									 const CHCICommandQItem& /*aRelatedCommand*/)
	{
	LOG_FUNC
	
	// Never resend.
	return MHCICmdQueueDecisionInterface::EContinueWithError;
	}
	
void CHCISymbianQdp::MhcqdiUnmatchedEventReceived(const THCIEventBase& /*aEvent*/)
	{
	LOG_FUNC
	
	// Notification function. No need to do anything.
	}

void CHCISymbianQdp::FixIgnoreInvalidHciParameterErrorOnSetEventMaskOnVersion1_1(THCIEventBase& aEvent)
	{
	LOG_FUNC
	// Some controllers supporting Bluetooth 1.1 return an EInvalidHCIParameter error
	// when SetEventMask is called. We still want to call SetEventMask and catch any actual
	// error in the stack (since it means that stack start up has failed).
	// In this case, stack start-up is fine, just ignore the returned EInvalidHCIParameter
	
	if(aEvent.ErrorCode() == EInvalidHCIParameter
	&& aEvent.EventCode() == ECommandCompleteEvent
	&& KSetEventMaskOpcode == THCICommandCompleteEvent::Cast(aEvent).CommandOpcode()
	&& iHCIVersion == EHWHCIv1_1)
		{
		LOG(_L8("Ignoring Invalid HCI Parameter error for Set Event Mask"));
		THCIEventModifiable& event = static_cast<THCIEventModifiable&>(aEvent);
		event.SetErrorCode(EOK);
		}
	}

void CHCISymbianQdp::FixFakeCompletionEventsOnDisconnection(THCIEventBase& aEvent)
	{
	LOG_FUNC
	// Some controllers fail to follow the HCI specification w.r.t. events on disconnection.
	// The specification indicates outstanding data on a connection handle to be considered
	// removed when a disconnection occurs.  Events however are not guarded by such text
	// and should always be returned (with an appropriate error code).
	// The command queue expects these events (as it is programmed to the spec) so if a
	// controller fails to perform the task, we have to make up the shortfall.  Currently
	// the following events are the ones that fail to be generated in the controllers. 
	// This issue has been observed with:
	//
	// * Authentication_Complete
	// * Read_Clock_Offset

	if(aEvent.EventCode() == EDisconnectionCompleteEvent)
		{
		const TDisconnectionCompleteEvent& disconnEvent = TDisconnectionCompleteEvent::Cast(aEvent);
		THCIConnectionHandle handle = disconnEvent.ConnectionHandle();
		THCIErrorCode reason = static_cast<THCIErrorCode>(disconnEvent.Reason());
		
		if(iProvider->FindOutstandingCommand(KAuthenticationRequestedOpcode))
			{
			LOG(_L8("Injecting Authentication Complete Event"));
			TAuthenticationCompleteEvent authenticationCompleteEvent(reason, handle, iEventModBuffer);
			iProvider->InjectEvent(authenticationCompleteEvent);
			}
		
		if(iProvider->FindOutstandingCommand(KReadClockOffsetOpcode))
			{
			LOG(_L8("Injecting Read Clock Offset Complete Event"));
			THCIClockOffset clockOffset = 0;
			TReadClockOffsetEvent readClockOffsetEvent(reason, handle, clockOffset, iEventModBuffer);
			iProvider->InjectEvent(readClockOffsetEvent);
			}
		}
	}

/**
Utility template class for FixAddConnectionHandleForTruncatedInvalidConnectionHandleErrorEvents function.
*/
template<class XCommandCompleteCommandClass>
struct AttemptToFixCommandCompleteEvent
	{
	static void CheckAndFix(THCICommandCompleteEvent& aEvent, const CHCICommandQItem* aRelatedCommand, TDes8& aNewBuffer, TInt aCorrectSize, TInt aExpectedSizeMissing)
		{
		LOG_STATIC_FUNC
		THCIEventModifiable& event = static_cast<THCIEventModifiable&>(static_cast<THCIEventBase&>(aEvent));
		// Check to see if the data is truncated - only apply the fix if it is
		if(event.EventData().Length() == (aCorrectSize-aExpectedSizeMissing))
			{
			// This is actually a best effort guess that the connection handle is missing.  Fixing this isn't simple because
			// we need a bigger buffer than we may have - so we have to create our own backing buffer for the event.
			LOG1(_L8("Modifying Command Complete event (opcode = 0x%04x) to add Connection Handle"), aEvent.CommandOpcode());
			aNewBuffer.FillZ(aCorrectSize); // ensure buffer is clean
			aNewBuffer.Copy(event.EventData());
			if(aRelatedCommand)
				{
				const XCommandCompleteCommandClass& cmd = static_cast<const XCommandCompleteCommandClass&>(aRelatedCommand->Command());
				AppendConnectionHandle(aNewBuffer, cmd.ConnectionHandle());
				}
			else
				{
				// we have no connection handle to insert in, so pick one that can
				// never be valid.
				AppendConnectionHandle(aNewBuffer, KInvalidConnectionHandle);
				}
			aNewBuffer.SetLength(aCorrectSize);
			event.EventData().Set(aNewBuffer); // update event to point to new buffer
			}
		// Ensure that now the event is correct.
		ASSERT_DEBUG(event.EventData().Length() == aCorrectSize);
		}
	};
	
void CHCISymbianQdp::FixAddConnectionHandleForTruncatedInvalidConnectionHandleErrorEvents(THCIEventBase& aEvent, const CHCICommandQItem* aRelatedCommand)
	{
	LOG_FUNC
	// Some controllers do not follow the HCI specification in that they do not always return
	// an event of the correct size - in this case controllers omit a connection handle field when
	// erroring with "invalid connection handle" error code.  One can argue about this but the
	// command queue is designed with the spec in mind so just adjust the events as appropriate.
	//
	// Notably command complete events are the events with issues; if a command status is used
	// then the error code is communicated without any other parameters, and the resulting events will 
	// not generally be generated (see FixFakeCompletionEventsOnDisconnection).
	// Current events that have observed (^) this issue (or could potentially have this issue (*)) are:
	//
	// ^ Command_Complete (Write_Link_Policy_Settings)
	// ^ Command_Complete (Read_Link_Policy_Settings)
	// * Command_Complete (Read_LMP_Handle)
	// ^ Command_Complete (Role_Discovery)
	// ^ Command_Complete (Sniff_Subrating)
	// * Command_Complete (Flush)
	// * Command_Complete (Read_Auto_Flush_Timeout)
	// * Command_Complete (Write_Auto_Flush_Timeout)
	// * Command_Complete (Read_Transmit_Power_Level)
	// * Command_Complete (Read_Link_Supervision_Timeout)
	// * Command_Complete (Write_Link_Supervision_Timeout)
	// * Command_Complete (Read_Failed_Contact_Counter)
	// * Command_Complete (Reset_Failed_Contact_Counter)
	// * Command_Complete (Read_Link_Quality)
	// * Command_Complete (Read_RSSI)
	// * Command_Complete (Read_AFH_Channel_Map)
	// * Command_Complete (Read_Clock)
	//
	// Only those actually observed as issues are included - the others are commented out for reference
	
	if(aEvent.ErrorCode() == ENoConnection)
		{
		if(aEvent.EventCode() == ECommandCompleteEvent)
			{
			THCICommandCompleteEvent& completeEvent = THCICommandCompleteEvent::Cast(aEvent);
			// Macro to make the code more concise
			#define _CHECK_AND_FIX(_COMMAND_NAME, _CORRECT_SIZE, _MISSING_SIZE) \
				case K##_COMMAND_NAME##Opcode:\
					AttemptToFixCommandCompleteEvent<C##_COMMAND_NAME##Command>::CheckAndFix(completeEvent, aRelatedCommand, iEventModBuffer, (_CORRECT_SIZE), (_MISSING_SIZE));\
					break
			switch(completeEvent.CommandOpcode())
				{
			_CHECK_AND_FIX(WriteLinkPolicySettings,		 8, sizeof(THCIConnHandle));
			_CHECK_AND_FIX(ReadLinkPolicySettings,		10, sizeof(THCIConnHandle) + sizeof(TUint16));
			_CHECK_AND_FIX(RoleDiscovery,				 9, sizeof(THCIConnHandle) + sizeof(TUint8));
			_CHECK_AND_FIX(SniffSubrating,				 8, sizeof(THCIConnHandle));
			
			// These below are included as they potentially could have the same problem,
			// however in practice this issue has not been observed.
		//	_CHECK_AND_FIX(ReadLMPHandle,				13, sizeof(THCIConnHandle) + sizeof(TUint8) + sizeof(TUint32));
		//	_CHECK_AND_FIX(Flush,						 8, sizeof(THCIConnHandle) + sizeof(TUint8) + sizeof(TUint32));
		//	_CHECK_AND_FIX(ReadAutomaticFlushTimeout,	10, sizeof(THCIConnHandle) + sizeof(TUint16));
		//	_CHECK_AND_FIX(WriteAutomaticFlushTimeout,	 8, sizeof(THCIConnHandle));
		//	_CHECK_AND_FIX(ReadTransmitPowerLevel,		 9, sizeof(THCIConnHandle) + sizeof(TUint8));
		//	_CHECK_AND_FIX(ReadLinkSupervisionTimeout,	10, sizeof(THCIConnHandle) + sizeof(TUint16));
		//	_CHECK_AND_FIX(WriteLinkSupervisionTimeout,	 8, sizeof(THCIConnHandle));
		//	_CHECK_AND_FIX(ReadFailedContactCounter,	10, sizeof(THCIConnHandle) + sizeof(TUint16));
		//	_CHECK_AND_FIX(ResetFailedContactCounter,	 8, sizeof(THCIConnHandle));
		//	_CHECK_AND_FIX(ReadLinkQuality,				 9, sizeof(THCIConnHandle));
		//	_CHECK_AND_FIX(ReadRSSI,					 9, sizeof(THCIConnHandle) + sizeof(TUint8));
		//	_CHECK_AND_FIX(ReadAFHChannelMap,			19, sizeof(THCIConnHandle) + sizeof(TUint8) + 10);
		//	_CHECK_AND_FIX(ReadClock,					14, sizeof(THCIConnHandle) + sizeof(TUint32) + sizeof(TUint16));
			
			default:
				// just ignore
				break;
				}
			#undef _CHECK_AND_FIX
			}
		}
	}

void CHCISymbianQdp::MhcqemiUnmatchedEventReceived(THCIEventBase& aEvent)
	{
	LOG_FUNC
	
#ifdef FAKE_COMPLETION_EVENTS_ON_DISCONNECTION
	FixFakeCompletionEventsOnDisconnection(aEvent);
#endif // FAKE_COMPLETION_EVENTS_ON_DISCONNECTION
	
	MhcqdiUnmatchedEventReceived(aEvent);
	}
	
MHCICmdQueueDecisionInterface::TCommandTimedOutAction CHCISymbianQdp::MhcqdiCommandTimedOut(const CHCICommandQItem& /*aCommand*/,
																							const TDblQue<const CHCICommandQItem>& /*aSentCommands*/,
																							TUint /*aCurrentCommandCredits*/,
																							TUint& aCreditsToBeRefunded)
	{
	LOG_FUNC
	
	// No Timeout ever set, should never be called.
	aCreditsToBeRefunded = KHCIDefaultCmdCredits;
	return EContinueWithTimeoutEvent;
	}
	
void CHCISymbianQdp::MhcqdiSetPhysicalLinksState(const MPhysicalLinksState& /*aPhysicalLinkState*/)
	{
	LOG_FUNC
	}
	
void CHCISymbianQdp::MhcqdiSetHardResetInitiator(const MHardResetInitiator& /*aHardResetInitiator*/)
	{
	LOG_FUNC
	}
	
void CHCISymbianQdp::MhcqdiSetHCICommandQueue(MHCICommandQueue& /*aHCICommandQueue*/)
	{
	LOG_FUNC
	}

void CHCISymbianQdp::MhcqdiSetTimeouts(TUint /*aQueueStarvationTimeout*/,
									   TUint /*aMaxHciCommandTimeout*/)
	{
	LOG_FUNC
	}
	
TUint CHCISymbianQdp::MhcqdiReset()
	{
	LOG_FUNC
	
	// Return the initial number of command credits for the queue.
	return KHCIDefaultCmdCredits;
	}

void CHCISymbianQdp::MhcquuSetUtilitiesProvider(MHCICmdQueueUtilities& aProvider)
	{
	LOG_FUNC
	
	iProvider = &aProvider;
	}