// 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/logger.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_QDP_SYMBIAN);

#endif

/*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

   if (!aSentCommands.IsEmpty())

   		{

        // Def088959 - The following unhandled commands are blocked to avoid operational errors.

        // 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.

        THCIOpcode opcode=aSentCommands.Last()->Command().Opcode();

        if (opcode == KHoldModeOpcode ||

        			opcode == KSniffModeOpcode ||

        			opcode == KExitSniffModeOpcode ||

        			opcode == KSwitchRoleOpcode ||

        			opcode == KParkModeOpcode ||

        			opcode == KExitParkModeOpcode)

	        {

        	return EBlock;

	        }

   		}

   //otherwise 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 BROKEN_CASIRA_1_1

	FirmwareFixIgnoreErrorOnSetEventMaskForCasira(aEvent);

#endif // BROKEN_CASIRA_1_1

#ifdef BROKEN_BELKIN_2_1

	FirmwareFixFakeCompletionEventsOnDisconnectionForBelkin(aEvent);

#endif // BROKEN_BELKIN_2_1

	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::FirmwareFixIgnoreErrorOnSetEventMaskForCasira(THCIEventBase& aEvent)

	{

	LOG_FUNC

	// Casiras with 1.1 firmware return an EInvalidHCIParameter error

	// when SetEventMask is called. We still want to call SetEventMask but

	// on this (old/buggy) firmware, ignore the returned EInvalidHCIParameter

	if (    aEvent.ErrorCode() == EInvalidHCIParameter

	    &&  aEvent.EventCode() == ECommandCompleteEvent

		&& KSetEventMaskOpcode == THCICommandCompleteEvent::Cast(aEvent).CommandOpcode()

		&&         iHCIVersion == EHWHCIv1_1)

		{

		THCIEventBase& modevent = const_cast<THCIEventBase&>(aEvent);

		THCIEventModifiable& event = reinterpret_cast<THCIEventModifiable&>(modevent);

		event.SetErrorCode(EOK);

		}

	}

void CHCISymbianQdp::FirmwareFixFakeCompletionEventsOnDisconnectionForBelkin(THCIEventBase& aEvent)

	{

	LOG_FUNC

	// For Belkin 2.1 controllers, if we receive a "Disconnection Complete Event"

	// then look for a "Authentication Requested" command or "Read Clock Offset" on

	// the sent queue, and if found, then fake up an completion event (with reason

	// code copied from the Disconnection Complete Event) and inject this into the

	// queue. This is because the Belkin 2.1 controllers fail to send a completion

	// event for "Read Clock Offset" and "Request Authentication" (and maybe others)

	// themselves (i.e. these are firmware bugs we're working around)

	if (aEvent.EventCode() == EDisconnectionCompleteEvent && iHCIVersion == EHWHCIv2_1)

		{

		const TDisconnectionCompleteEvent& disconnEvent = TDisconnectionCompleteEvent::Cast(aEvent);

		THCIConnectionHandle handle = disconnEvent.ConnectionHandle();

		THCIErrorCode reason = static_cast<THCIErrorCode>(disconnEvent.Reason());

		if (iProvider->FindOutstandingCommand(KAuthenticationRequestedOpcode) != NULL)

			{

			TBuf8<KHCIMaxEventSize> eventBuf1;

			TAuthenticationCompleteEvent authenticationCompleteEvent(reason, handle, eventBuf1);

			iProvider->InjectEvent(authenticationCompleteEvent);

			}

		if (iProvider->FindOutstandingCommand(KReadClockOffsetOpcode) != NULL)

			{

			TBuf8<KHCIMaxEventSize> eventBuf2;

			THCIClockOffset clockOffset = 0;

			TReadClockOffsetEvent readClockOffsetEvent(reason, handle, clockOffset, eventBuf2);

			iProvider->InjectEvent(readClockOffsetEvent);

			}

		}

	}

void CHCISymbianQdp::MhcqemiUnmatchedEventReceived(THCIEventBase& aEvent)

	{

	LOG_FUNC

#ifdef BROKEN_BELKIN_2_1

	FirmwareFixFakeCompletionEventsOnDisconnectionForBelkin(aEvent);

#endif // BROKEN_BELKIN_2_1

	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;

	}