// Copyright (c) 2006-2010 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:

// This file is made up of 4 different sections:

// - Command Complete processing functions

// These are private functions that implement a specific command 

// complete event, one per handled opcode.

// - Event processing functions

// These are private functions that implement a specific

// command event, one per handled event. These events may or may not

// be matched to a particular command. 

// - Data event processing functions

// These are private functions that implement a specific data event,

// one per handled event.

// - HCI APIs

// These are the functions that are called directly by the 

// different parts of the HCI and make up the MHCICommandQueueClient 

// and MHCIDataEventObserver interfaces.

// 

//

#include <bluetooth/logger.h>

#include "hcifacade.h"

#include "physicallinksmanager.h"

#include "linkmgr.h"

#include "hostresolver.h"

#include "linkutil.h"

#include "linkmuxer.h"

#include "linkflowcontrol.h"

#include "linkconsts.h"

#include "VendorSAP.h"

#include "vendorspecific.h"

#include "AclDataQController.h"

#include "pairingserver.h"

#include "oobdata.h"

#include <e32std.h>

#include <bt_sock.h>

#include <utf.h>

#include <es_ini.h>

#include <btextnotifiers.h>

#include <bluetooth/hcicommandqueue.h>

#include <bluetooth/hci/hciopcodes.h>

#include <bluetooth/hci/command.h>

// Command Events

#include <bluetooth/hci/connectioncompleteevent.h>

#include <bluetooth/hci/connectionrequestevent.h>

#include <bluetooth/hci/disconnectioncompleteevent.h>

#include <bluetooth/hci/authenticationcompleteevent.h>

#include <bluetooth/hci/encryptionchangeevent.h>

#include <bluetooth/hci/readremsuppfeatcompleteevent.h>

#include <bluetooth/hci/readremoteextendedfeaturescompleteevent.h>

#include <bluetooth/hci/readremverinfocompleteevent.h>

#include <bluetooth/hci/commandstatusevent.h>

#include <bluetooth/hci/hardwareerrorevent.h>

#include <bluetooth/hci/rolechangeevent.h>

#include <bluetooth/hci/numberofcompletedpacketsevent.h>

#include <bluetooth/hci/modechangeevent.h>

#include <bluetooth/hci/pincoderequestevent.h>

#include <bluetooth/hci/linkkeyrequestevent.h>

#include <bluetooth/hci/linkkeynotificationevent.h>

#include <bluetooth/hci/maxslotschangeevent.h>

#include <bluetooth/hci/readclockoffsetevent.h>

#include <bluetooth/hci/connectionpackettypechangedevent.h>

#include <bluetooth/hci/linksupervisiontimeoutchangedevent.h>

#include <bluetooth/hci/synchronousconnectioncompleteevent.h>

#include <bluetooth/hci/vendordebugevent.h>

#include <bluetooth/hci/vendordebugcompleteevent.h>

#include <bluetooth/hci/writesimplepairingmodecommand.h>

#include <bluetooth/hci/readlocalsupportedcommandscommand.h>

// Command Complete Events

#include <bluetooth/hci/writelinkpolicysettingscompleteevent.h>

#include <bluetooth/hci/readbdaddrcompleteevent.h>

#include <bluetooth/hci/readbuffersizecompleteevent.h>

#include <bluetooth/hci/readclassofdevicecompleteevent.h>

#include <bluetooth/hci/readlocalversioninfocompleteevent.h>

#include <bluetooth/hci/flushcompleteevent.h>

#include <bluetooth/hci/readlocalsupportedfeaturescompleteevent.h>

#include <bluetooth/hci/readlocalsupportedcommandscompleteevent.h>

#include <bluetooth/hci/readlocaloobdatacompleteevent.h>

#include <bluetooth/hci/remoteoobdatarequestreplycompleteevent.h>

#include <bluetooth/hci/remoteoobdatarequestnegativereplycompleteevent.h>

#include <bluetooth/hci/readinquiryresponsetransmitpowerlevelcompleteevent.h>

// Related commands

#include <bluetooth/hci/readremoteextendedfeaturescommand.h>

#include <bluetooth/hci/readinquiryresponsetransmitpowerlevelcommand.h>

#include <bluetooth/hci/hostbuffersizecommand.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_HCI_FACADE);

#endif

// ----------------------------------------------------------------------------

// Command Complete processing functions

// ----------------------------------------------------------------------------

void CHCIFacade::WriteLinkPolicySettingsOpcode(THCIErrorCode aHciErr, const THCIEventBase* aEvent, const CHCICommandBase* /*aRelatedCommand*/)

	{

	LOG_FUNC

	THCIConnHandle connH(KInvalidConnectionHandle);

	if (aEvent != NULL)

		{

		const TWriteLinkPolicySettingsCompleteEvent& writeLinkPolicyCompleteEvent = TWriteLinkPolicySettingsCompleteEvent::Cast(*aEvent);

		connH = writeLinkPolicyCompleteEvent.ConnectionHandle();

		}

	iLinksMgr->WriteLinkPolicySettingsCompleteEvent(aHciErr, connH);

	}

void CHCIFacade::ResetOpcode(THCIErrorCode /*aHciErr*/, const THCIEventBase* /*aEvent*/, const CHCICommandBase* /*aRelatedCommand*/)

	{

	LOG_FUNC

	// We only expect a reset command event when we are initialising

	__ASSERT_ALWAYS(iInitState == EResetting, Panic(EHCICmdQNotInitialising));

	iInitState = EReset;

	if (iControllerInitialisor != NULL)

		{

		iControllerInitialisor->MciiPostResetCommand();

		}

	else

		{

		// There is no initialisation plugin so behave as if there

		// were and it had completed its post reset phase

		McioPostResetCommandComplete(KErrNone);

		}

	}

void CHCIFacade::ReadBdaddrOpcode(THCIErrorCode aHciErr, const THCIEventBase* aEvent, const CHCICommandBase* /*aRelatedCommand*/)

/**

	Got the local address

	Tell LinkMgr protocol

**/

	{

	LOG_FUNC

	if ((aHciErr == EOK) && (aEvent != NULL))

		{

		const TReadBdaddrCompleteEvent& readBdaddrCompleteEvent = TReadBdaddrCompleteEvent::Cast(*aEvent);

		iLinkMgrProtocol.SetLocalBTAddress(readBdaddrCompleteEvent.BDADDR());

		}

	// do nothing if error

	}

void CHCIFacade::ReadBufferSizeOpcode(THCIErrorCode aHciErr, const THCIEventBase* aEvent, const CHCICommandBase* /*aRelatedCommand*/)

	{

	LOG_FUNC

	if ((aHciErr == EOK) && (aEvent != NULL))

		{

		const TReadBufferSizeCompleteEvent& readBufSizeCompleteEvent = TReadBufferSizeCompleteEvent::Cast(*aEvent);

		TUint aclPacketLen = readBufSizeCompleteEvent.HCACLDataPacketLength();

		TUint scoPacketLen = readBufSizeCompleteEvent.HCSynchronousDataPacketLength();

		TUint noAclPackets = readBufSizeCompleteEvent.HCTotalNumACLDataPackets();

		TUint noScoPackets = readBufSizeCompleteEvent.HCTotalNumSynchronousDataPackets();

		iLinkMuxer->HandleLocalReadBufferSizeResult(aclPacketLen, scoPacketLen, noAclPackets, noScoPackets);

		LOG3(_L("Link [HCIFacade_Events.cpp]: ReadBufferSizeResult - aErr %d, aAclMaxLen %d, aNoACL %d"), aHciErr, aclPacketLen, noAclPackets);

		}

	}

void CHCIFacade::ReadClassOfDeviceOpcode(THCIErrorCode aHciErr, const THCIEventBase* aEvent, const CHCICommandBase* /*aRelatedCommand*/)

	{

	LOG_FUNC

	TUint cod(0);

	if ((aHciErr == EOK) && (aEvent != NULL))

		{

		const TReadClassOfDeviceCompleteEvent& readCoDCompleteEvent = TReadClassOfDeviceCompleteEvent::Cast(*aEvent);

		cod = readCoDCompleteEvent.ClassOfDevice();

		}

	LOG2(_L("HCIFacade: ReadClassOfDevice Result Event (%d, 0x%x)"), aHciErr, cod);

	iLinkMgrProtocol.UpdateDeviceClass(aHciErr == EOK, cod);

	}

void CHCIFacade::WriteLocalNameOpcode(THCIErrorCode aHciErr, const THCIEventBase* /*aEvent*/, const CHCICommandBase* /*aRelatedCommand*/)

	{

	LOG_FUNC

	LOG(_L("HCIFacade: SetLocalName Command Complete Event"));

	iLinkMgrProtocol.InquiryMgr().SetLocalNameComplete(CHciUtil::SymbianErrorCode(aHciErr));

	iLinkMgrProtocol.UpdateLocalDeviceName(aHciErr == EOK);

	}

void CHCIFacade::WriteCurrentIACLAPOpcode(THCIErrorCode aHciErr, const THCIEventBase* /*aEvent*/, const CHCICommandBase* /*aRelatedCommand*/)

	{

	LOG_FUNC

	LOG(_L("HCIFacade: WriteCurrentIACLAP Command Complete Event"));

	iLinkMgrProtocol.UpdateLimitedDiscoverable(aHciErr == EOK);

	}

void CHCIFacade::WriteClassOfDeviceOpcode(THCIErrorCode aHciErr, const THCIEventBase* /*aEvent*/, const CHCICommandBase* /*aRelatedCommand*/)

	{

	LOG_FUNC

	LOG(_L("HCIFacade: WriteClassOfDevice Command Complete Event"));

	iLinkMgrProtocol.UpdateDeviceClass(aHciErr == EOK);

	}

void CHCIFacade::SetControllerToHostFlowControlOpcode(THCIErrorCode aHciErr, const THCIEventBase* /*aEvent*/, const CHCICommandBase* /*aRelatedCommand*/)

	{

	LOG_FUNC

	LOG1(_L8("HCIFacade: SetControllerToHostFlowControl Command Complete Event (result = 0x%02x)"), aHciErr);

	if(aHciErr == EOK)

		{

		// flow control mode set - so provide the host buffer settings

		CHCICommandBase* command = NULL;

		TRAPD(err, command = CHostBufferSizeCommand::NewL(KStackACLBuffersSize, KStackSCOBuffersSize, 

											KStackACLBuffersNum, KStackSCOBuffersNum));

		if(err == KErrNone)

			{

			err = SendInitialisationCommand(command);

			}

		if(err != KErrNone)

			{

			// unfortunately at this stage we are stuck since we need to inform

			// the controller of our buffers.  We've failed to initialise.

			LOG1(_L8("Failed to send HostBufferSize command(%d) - initialisation failed"), err);

			iInitialisationError = ETrue;

			}

		}

	else // we'll drop back to no flow control to the host

		{

		iLinkMuxer->RecordHostControllerToHostFlowControl(EFalse);

		}

	}

void CHCIFacade::HostBufferSizeOpcode(THCIErrorCode aHciErr, const THCIEventBase* /*aEvent*/, const CHCICommandBase* /*aRelatedCommand*/)

	{

	LOG_FUNC

	LOG1(_L8("HCIFacade: HostBufferSizeOpcode Command Complete Event (result = 0x%02x)"), aHciErr);

	if(aHciErr == EOK)

		{

		// all set-up for controller to host flow-control

		iLinkMuxer->RecordHostControllerToHostFlowControl(ETrue);

		}

	else

		{

		// If we've failed to perform this command then the stack is stuck

		// half initialised to perform controller to host flow control.

		LOG(_L8("Failed to set the host buffer size in controller - initialisation failed"));

		iInitialisationError = ETrue;

		}

	}

void CHCIFacade::WriteScanEnableOpcode(THCIErrorCode aHciErr, const THCIEventBase* /*aEvent*/, const CHCICommandBase* /*aRelatedCommand*/)

	{

	LOG_FUNC

	LOG(_L("HCIFacade: WriteScanEnable Command Complete Event"));

	iLinkMgrProtocol.UpdateLocalDeviceScanEnable(aHciErr == EOK);

	}

void CHCIFacade::SetAFHHostChannelClassificationOpcode(THCIErrorCode /*aHciErr*/, const THCIEventBase* /*aEvent*/, const CHCICommandBase* /*aRelatedCommand*/)

	{

	LOG_FUNC

	LOG(_L("HCIFacade: WriteAFHHostChannelClassification Command Complete Event"));

	//Update timer to fire after required interval

	//between AFH Host Channel Classification Commands 

	iAFHTimer->Cancel();

	iAFHTimer->After(KAFHHostChannelClassificationIntervalTimer);

	}

void CHCIFacade::WriteAFHChannelAssessmentModeOpcode(THCIErrorCode aHciErr, const THCIEventBase* /*aEvent*/, const CHCICommandBase* /*aRelatedCommand*/)

	{

	LOG_FUNC

	LOG(_L("HCIFacade: WriteAFHChannelAssessmentMode Command Complete Event"));

	//If 'status' is not EOK, the registry will not be updated. In particular, if

	//channel assessment is not supported the AFHChannelAssessmentMode

	//will remain set to ETrue. As this value is only used to update the 

	//controller, it does not matter.

	iLinkMgrProtocol.UpdateAFHChannelAssessmentMode(aHciErr == EOK);

	}

void CHCIFacade::ReadLocalVersionInfoOpcode(THCIErrorCode aHciErr, const THCIEventBase* aEvent, const CHCICommandBase* /*aRelatedCommand*/)

	{

	LOG_FUNC

	TBTDevHCIVersion hciVersion;

	TBTDevLMPVersion lmpVersion;

	if (aEvent != NULL)

		{

		const TReadLocalVersionInfoCompleteEvent& readLocalVersionCompleteEvent = TReadLocalVersionInfoCompleteEvent::Cast(*aEvent);

		hciVersion.iHCIVersion = readLocalVersionCompleteEvent.Version();

		hciVersion.iHCIRevision = readLocalVersionCompleteEvent.Revision();

		lmpVersion.iLMPVersion = readLocalVersionCompleteEvent.LMPVersion();

		lmpVersion.iManufacturerID = readLocalVersionCompleteEvent.ManufacturerName();

		lmpVersion.iLMPSubVersion = readLocalVersionCompleteEvent.LMPSubversion();

		}

	iLinkMgrProtocol.SetLocalVersion(aHciErr, hciVersion, lmpVersion);

	if(aHciErr == EOK && aEvent)

		{

		if(hciVersion.iHCIVersion > EHWHCIv1_1) // Only send a supported commands command

			{

			CReadLocalSupportedCommandsCommand* cmd = NULL;

			TRAPD(err, cmd = CReadLocalSupportedCommandsCommand::NewL());

			if(err == KErrNone)

				{

				static_cast<void>(SendInitialisationCommand(cmd));

				}

			}

		}

	iReadLocalVersionComplete = ETrue;

	if (iReadLocalSupportedFeaturesComplete)

		{

		SetSupportedEventMasks();		

		}

	}

void CHCIFacade::SetSupportedEventMasks()

	{

	TBTDevHCIVersion hciVersion;

	TUint32 supportedEventMaskLoBytes;

	TUint32 supportedEventMaskHiBytes;

	// We Dont mask the LoBytes events yet

	supportedEventMaskLoBytes = THCIEventMask::KDefaultLoBytes;

	supportedEventMaskHiBytes = THCIEventMask::KDefaultHiBytes;

	hciVersion = iLinkMgrProtocol.GetHWHCIVersion();

	if (hciVersion.iHCIVersion < EHWHCIv1_2)

		{

		// By default we support the core spec v1.2 however the HiBytes for the supported

		// events are not used pre v1.2 and by clearing them it allows us to work with old 

		// controllers if required

		supportedEventMaskHiBytes = 0;

		}		

	if (iLinkMgrProtocol.IsExtendedInquiryResponseSupportedLocally())

		{ 

		supportedEventMaskHiBytes |=	THCIEventMask::EExtendedInquiryResultEvent;

		}

	if (iLinkMgrProtocol.IsSecureSimplePairingSupportedLocally())

		{  

		supportedEventMaskHiBytes |=	THCIEventMask::EIOCapabilityRequestEvent|

										THCIEventMask::EIOCapabilityRequestReplyEvent|

										THCIEventMask::EUserConfirmationRequestEvent|

										THCIEventMask::EUserPasskeyRequestEvent|

										THCIEventMask::ERemoteOOBDataRequestEvent|

										THCIEventMask::ESimplePairingCompleteEvent|

										THCIEventMask::EUserPasskeyNotificationEvent|

										THCIEventMask::EKeypressNotificationEvent;

		}

	if (hciVersion.iHCIVersion == EHWHCIv2_1)

		{  

		supportedEventMaskHiBytes |=	THCIEventMask::ERemoteHostSupportedFeaturesNotificationEvent;

		supportedEventMaskHiBytes |=	THCIEventMask::ELinkSupervisionTimeoutChangedEvent;

		supportedEventMaskHiBytes |=	THCIEventMask::EEncryptionKeyRefreshCompleteEvent;

		supportedEventMaskHiBytes |=	THCIEventMask::ERemoteHostSupportedFeaturesNotificationEvent;

		}		

	THCIEventMask eventMask = {supportedEventMaskLoBytes, supportedEventMaskHiBytes};

	TRAPD(err, SetEventMaskL(eventMask));

	__ASSERT_DEBUG(err == KErrNone, Panic(EHCIControllerInitialisation));

	(void) (err != err);

	}

void CHCIFacade::ReadLocalSupportedFeaturesOpcode(THCIErrorCode aHciErr, const THCIEventBase* aEvent, const CHCICommandBase* /*aRelatedCommand*/)

	{

	LOG_FUNC

	if ((aHciErr == EOK) && (aEvent != NULL))

		{

		const TReadLocalSupportedFeaturesCompleteEvent& readLocalFeaturesCompleteEvent = TReadLocalSupportedFeaturesCompleteEvent::Cast(*aEvent);

		TBTFeatures features(readLocalFeaturesCompleteEvent.LMPFeatures());

		iLinkMgrProtocol.SetLocalFeatures(aHciErr, features);

		if(iLinkMgrProtocol.IsSecureSimplePairingSupportedLocally())

			{

			CWriteSimplePairingModeCommand* cmd = NULL;

			TRAPD(err, cmd = CWriteSimplePairingModeCommand::NewL(ESimplePairingEnabled));

			if(err == KErrNone)

			    {

                err = SendInitialisationCommand(cmd);

			    }

			if(err != KErrNone)

			    {

                LOG(_L("HCIFacade: ReadLocalSupportedFeaturesOpcode Error"));

                iInitialisationError = ETrue;

			    }

			}

		else

			{

			iLinksMgr->SecMan().SetLocalSimplePairingMode(EFalse);

			}

		}

	else

		{

		iLinkMgrProtocol.SetLocalFeatures(aHciErr, TBTFeatures(0));

		iLinksMgr->SecMan().SetLocalSimplePairingMode(EFalse); // for want of a better solution

		}

	iReadLocalSupportedFeaturesComplete = ETrue;

	if (iReadLocalVersionComplete)

		{

		SetSupportedEventMasks();		

		}

	}

void CHCIFacade::ReadLocalSupportedCommandsOpcode(THCIErrorCode aHciErr, const THCIEventBase* aEvent, const CHCICommandBase* /*aRelatedCommand*/)

	{

	LOG_FUNC

	if ((aHciErr == EOK) && (aEvent != NULL))

		{

		const TReadLocalSupportedCommandsCompleteEvent& readLocalCommandsCompleteEvent = TReadLocalSupportedCommandsCompleteEvent::Cast(*aEvent);

		TBluetoothHciCommands commands(readLocalCommandsCompleteEvent.SupportedCommands());

		iLinkMgrProtocol.SetLocalCommands(aHciErr, commands);

		if (iLinkMgrProtocol.IsCommandSupportedLocally(ESupportedReadInquiryResponseTransmitPowerCommand))

			{

			CReadInquiryResponseTransmitPowerLevelCommand* cmd = NULL;

			TRAP_IGNORE(cmd = CReadInquiryResponseTransmitPowerLevelCommand::NewL());

			if(cmd)

				{

				static_cast<void>(SendInitialisationCommand(cmd));

				}

			}

		}

	else

		{

		TBluetoothHciCommands commands;

		iLinkMgrProtocol.SetLocalCommands(aHciErr, commands);

		}

	}

void CHCIFacade::FlushOpcode(THCIErrorCode aHciErr, const THCIEventBase* aEvent, const CHCICommandBase* /*aRelatedCommand*/)

	{

	LOG_FUNC

	THCIConnHandle connH(KInvalidConnectionHandle);

	if (aEvent != NULL)

		{

		const TFlushCompleteEvent& flushCompleteEvent = TFlushCompleteEvent::Cast(*aEvent);

		connH = flushCompleteEvent.ConnectionHandle();

		}

	LOG(_L("Link [HCIFacade_Events.cpp]: FlushCompleteEvent"));

	iLinkMgrProtocol.ACLController().FlushComplete(CHciUtil::SymbianErrorCode(aHciErr), connH);

	}

void CHCIFacade::SwitchRoleOpcode(THCIErrorCode aHciErr, const THCIEventBase* /*aEvent*/, const CHCICommandBase* /*aRelatedCommand*/)

	{

	LOG_FUNC

	if (aHciErr != EOK)

		{

		// Role change failed, probably "Role change not allowed", notify clients

		iLinksMgr->RoleChangeRejectedByHW(aHciErr);

		return;						

		}		

	}

void CHCIFacade::SetEventMaskOpcode(THCIErrorCode __DEBUG_ONLY(aHciErr), const THCIEventBase* /*aEvent*/, const CHCICommandBase* /*aRelatedCommand*/)

	{

	LOG_FUNC

	#ifdef _DEBUG

	LOG1(_L("HCIFacade: SetEventMask Result Event (%d)"), aHciErr); // leave in at all?

	#endif

	__ASSERT_DEBUG(aHciErr ==  EOK, Panic(EHCIControllerInitialisation));

	iLinkMgrProtocol.LocalSupportedFeaturesAvailable();

	}

void CHCIFacade::ReadInquiryResponseTransmitPowerLevelOpcode(THCIErrorCode aHciErr, const THCIEventBase* aEvent, const CHCICommandBase* /*aRelatedCommand*/)

	{

	if (aHciErr == EOK && aEvent)

		{

		const TReadInquiryResponseTransmitPowerLevelCompleteEvent& readInquiryResponseTransmitPowerLevelCompleteEvent = TReadInquiryResponseTransmitPowerLevelCompleteEvent::Cast(*aEvent);

		TInt8 txPowerLevel = readInquiryResponseTransmitPowerLevelCompleteEvent.TxPowerLevel();

		iLinkMgrProtocol.UpdateInquiryResponseTxPowerLevel(txPowerLevel);

		FTRACE(FPrint(_L("HCIFacade: TxPowerLevel (%d)"), txPowerLevel));

		}

	}

// ----------------------------------------------------------------------------

// Event processing functions

// ----------------------------------------------------------------------------

void CHCIFacade::ConnectionCompleteEvent(const THCIEventBase& aEvent, const CHCICommandBase* aRelatedCommand)

	/**

	   Some connection request has completed.

	   This may be a successful connection complete, or a failure.

	**/

	{

	LOG_FUNC

	TBTConnect conn;

	const TConnectionCompleteEvent& connCompleteEvent = TConnectionCompleteEvent::Cast(aEvent);

	THCIErrorCode err = aEvent.ErrorCode();

	conn.iConnH = connCompleteEvent.ConnectionHandle();

	conn.iBdaddr = connCompleteEvent.BDADDR();

	conn.iLinkType = TLinkType(connCompleteEvent.LinkType());

	conn.iEncryptMode = TEncryptMode(connCompleteEvent.EncryptionMode());

	LOG2(_L("Link [HCIFacade_Events.cpp]: Connection complete event. Code %d, link type=%d [from]"), err,conn.iLinkType);

	LOGHEXDESC(conn.iBdaddr.Des());

	iLinksMgr->ConnectionComplete(err, conn);

	if(!aRelatedCommand  ||