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

// The conduit to the HCI and HW - formulates and Qs commands, and implements HCI events

// 

//

#include <bluetooth/logger.h>

#include "hcifacade.h"

#include "linkmgr.h"

#include "hostresolver.h"

#include "linkutil.h"

#include "AclDataQController.h"

#include "linkmuxer.h"

#include "linkconsts.h"

#include <e32std.h>

#include <e32cmn.h>

#include <bt_sock.h>

#include <es_ini.h>

#include <e32base.h>

#include <bluetooth/hcicommandqueue.h>

#include <bluetooth/hcicommandqitem.h>

#include <bluetooth/hcicmdqcontroller.h>

#include <bluetooth/hci/controllerinitialisationinterface.h>

#include <bluetooth/hci/hcidataframer.h>

#include <bluetooth/hci/readlocalsupportedfeaturescommand.h>

#include <bluetooth/hci/hostbuffersizecommand.h>

#include <bluetooth/hci/resetcommand.h>

#include <bluetooth/hci/readbdaddrcommand.h>

#include <bluetooth/hci/readlocalversioninfocommand.h>

#include <bluetooth/hci/writeconnectionaccepttimeoutcommand.h>

#include <bluetooth/hci/writevoicesettingcommand.h>

#include <bluetooth/hci/readclassofdevicecommand.h>

#include <bluetooth/hci/readbuffersizecommand.h>

#include <bluetooth/hci/setcontrollertohostflowcontrolcommand.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_HCI_FACADE);

#endif

// definitions

const TBasebandTime TBasebandPolicy::KPageTimeoutR0 = static_cast<TBasebandTime>(2.56 /*seconds*/ / KBasebandSlotTime); // in baseband slots

const TBasebandTime TBasebandPolicy::KPageTimeoutR1 = static_cast<TBasebandTime>(5.12 /*seconds*/ / KBasebandSlotTime); // in baseband slots

const TBasebandTime TBasebandPolicy::KPageTimeoutR2 = static_cast<TBasebandTime>(10.24 /*seconds*/ / KBasebandSlotTime); // in baseband slots

const TReal TBasebandPolicy::KBestEffortTimeMultiplier = 2;

const TReal TBasebandPolicy::KQuickTimeMultiplier = 0.5;

_LIT(KHciUtilComponentName, "bluetooth_stack");

CHCIFacade* CHCIFacade::NewL(CLinkMgrProtocol& aProtocol)

	{

	LOG_STATIC_FUNC

	CHCIFacade* p= new (ELeave) CHCIFacade(aProtocol);

	CleanupStack::PushL(p);

	p->ConstructL();

	CleanupStack::Pop();

	return p;

	}

void CHCIFacade::ConstructL()

/**

   2nd phase construct the HCI Facade.

   This is where the stack loads both the HCI CommandQ and the CoreHCI and

   then distributes the required APIs between the different components.

**/

	{

	LOG_FUNC

	// Create HCI CommandQ

	iCmdController = CHCICmdQController::NewL();

	// Create HCI Utility library

	iHciUtil = CHciUtil::NewL(KHciUtilComponentName);

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

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

	TRAP_IGNORE(iHciUtil->OpenIniFileL());

	// Create Core HCI plugin

	_LIT(KSection, "CoreHci");

	_LIT(KCoreHciUidTag, "EcomUid");

	TUid coreHciImplUid = TUid::Null();

	TRAPD(err, coreHciImplUid = iHciUtil->GetUidFromFileL(KSection, KCoreHciUidTag));

	if (err == KErrNone)

		{

		// Valid UID found, load it

		iCoreHciPlugin = CCoreHCIPlugin::NewL(coreHciImplUid);

		}

	else

		{

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

		// implementation

		iCoreHciPlugin = CCoreHCIPlugin::NewL();

		}

	// Get Core HCI APIs

	iCoreHci = static_cast<MCoreHci*>(iCoreHciPlugin->Interface(TUid::Uid(KCoreHciInterfaceUid)));

	iHctl = static_cast<MHCTLInterface*>(iCoreHciPlugin->Interface(TUid::Uid(KHCTLInterfaceUid)));

	iControllerInitialisor = static_cast<MControllerInitialisationInterface*>

								(iCoreHciPlugin->Interface(TUid::Uid(KControllerInitialisationInterfaceUid)));

	if (iControllerInitialisor != NULL)

		{

		// attempt to get the Controller Initialisation Abort Extension API

		iControllerInitAbortExtension = static_cast<MControllerInitialisationAbortExtensionInterface*>

								(iCoreHciPlugin->Interface(TUid::Uid(KControllerInitialisationAbortExtenstionInterfaceUid)));

		}

	iDataFramer = static_cast<MHCIDataFramer*>(iCoreHciPlugin->Interface(TUid::Uid(KHCIDataFramerInterfaceUid)));

	iHardResetInitiator = static_cast<MHardResetInitiator*>(iCoreHciPlugin->Interface(TUid::Uid(KHCHardResetUid)));

	// Panic if we don't get the required interfaces, note that the initialisor

	// interface is optional

	__ASSERT_ALWAYS(iCoreHci && iHctl && iDataFramer && iHardResetInitiator,

					Panic(EHCIIncompleteInterfaces));

	// Provide direct APIs

	iCmdController->SetLinkMuxNotifier(*this);

	iCmdController->SetHCIUnmatchedEventObserver(*this);

	iCmdController->SetHardResetInitiator(*this);

	iCmdController->SetPhysicalLinksState(*this);

	iCoreHci->MchSetHardResetInitiator(*this);

	iCoreHci->MchSetPhysicalLinksState(*this);	

	iCoreHci->MchSetDataEventObserver(*this);

	iCoreHci->MchSetDataObserver(*this);

	iCoreHci->MchSetChannelObserver(*this);

	iCoreHci->MchSetControllerStateObserver(*this);

	// Provide Core HCI with CommandQ components

	iCoreHci->MchSetCommandEventObserver(*(static_cast<MHCICommandEventObserver*>(iCmdController)));

	iCoreHci->MchSetHCICommandQueue(*(static_cast<MHCICommandQueue*>(iCmdController)));

	// Provide CommandQ with HCI components

	iCmdController->SetHCTLInterface(*iHctl);

	iCmdController->SetHCICommandAllocator(*(static_cast<MHCICommandAllocator*>(iCoreHciPlugin->Interface(TUid::Uid(KHCICommandAllocatorInterfaceUid)))));

	// Initialise initialisor plugin if present

	if (iControllerInitialisor != NULL)

		{

		// Provide Initialisor with Stack

		iControllerInitialisor->MciiSetControllerInitialisationObserver(*this);

		// Provide Initialisor with CommandQ

		iControllerInitialisor->MciiSetHCICommandQueue(*(static_cast<MHCICommandQueue*>(iCmdController)));

		}

	// Attempt to supply the HCI with the Client Usage API

	MHCIClientUsageCallback* hciClientUsageCallback = static_cast<MHCIClientUsageCallback*>

								(iCoreHciPlugin->Interface(TUid::Uid(KHCIClientUsageCallbackUid)));

	if (hciClientUsageCallback)

		{

		// Support for the Client Usage Callback API is optional for CoreHCI plugins, pass the HCI

		// the Client Usage API if supported.

		hciClientUsageCallback->MhcucSetClientUsage(*this);

		}

	iAFHTimer=CAFHTimer::NewL(*this);

	// Read low power mode override timeout from the configuration file

	_LIT(KLPMSection, "lowpowermodeconfiguration");

	_LIT(KLPMTag, "overridelpmtimeout_microseconds");

	TUint overrideLPMTimeout = 0;

	TRAP(err, overrideLPMTimeout = iHciUtil->GetValueFromFileL(KLPMSection, KLPMTag));

	if (err == KErrNone)

		{

		// LPM override timeout found, pass the value into link manager

		iLinkMgrProtocol.SetOverrideLPMTimeout(overrideLPMTimeout);

		}

	iLastPowerState = EBTOn;

	// used later to ensure that we have enough data to call SetEventMask

	iReadLocalSupportedFeaturesComplete = EFalse;

	iReadLocalVersionComplete           = EFalse;

#ifdef HOSTCONTROLLER_TO_HOST_FLOW_CONTROL

	iMBufPool = CHostMBufPool::NewL(*this);

#endif

	}

void CHCIFacade::SetLinkMuxer(CLinkMuxer& aLinkMuxer)

	{

	LOG_FUNC

	iLinkMuxer=&aLinkMuxer;

	}

void CHCIFacade::SetPhysicalLinksMgr(CPhysicalLinksManager& aLinksMgr)

	{

	LOG_FUNC

	iLinksMgr = &aLinksMgr;

	}

TInt CHCIFacade::SendInitialisationCommand(CHCICommandBase* aCommand)

	/*

	  This method takes ownership of the command.

	*/

	{

	LOG_FUNC

	__ASSERT_ALWAYS(aCommand != NULL, Panic(EHCICommandNullItem));

	__ASSERT_ALWAYS(iInitState==EResetting || iInitState==EPostReset, Panic(EHCICtrlrInitAddingInitialisationCommandInBadState));

	if(iInitState==EResetting)

		{

		__ASSERT_ALWAYS(iOutstandingCommands.Count()==0, Panic(EHCICtrlrInitOnlyOneResetCmdAllowed));

		}

	TInt err = KErrNone;

	TUint qid = 0;

	// Ownership of the command is passed to the queue.

	// MhcqAddInitCommandL guarantees to take ownership even if it

	// leaves.

	// see CHCIFacade::MhcqcCommandEventReceived for completion

	TRAP(err, qid = iCmdController->MhcqAddInitCommandL(aCommand, *this));

	if (err != KErrNone)

		{

		iInitialisationError = ETrue;

		LOG1(_L("Error! CHCIFacade::SendInitialisationCommand %d"), err);

		return err;

		}

	// We need to know when we have completed initialisation of the stack so that

	// we can Start() the HCI Command Queue. To do this we keep a list of all the

	// initialisation command opcodes and then remove them from the list when we

	// get the corresponding completion event. The stack initialisation is complete

	// when the list of opcodes is empty.

	if ((err = AddOutstandingCommandOpCode(aCommand->Opcode()))	!= KErrNone)

		{

		if (iCmdController->MhcqRemoveCommand(qid, *this) != KErrNone)

			{

			Panic(EHCICtrlrInitFailedToRemoveCmd);

			}

		iInitialisationError = ETrue;

		LOG1(_L("Error! CHCIFacade::SendInitialisationCommand %d"), err);

		return err;

		}

	return KErrNone;

	}

void CHCIFacade::InitL(const TBTLocalDevice& aDeviceConfig)

/**

	The start-up strategy

	If there is an Initialisor the pre-reset initialisation method will

	be called on it at this point. When the Initialisor pre-reset method

	completes the stack will be called back to enable it to send the HCI

	reset command, see McioPreResetCommandComplete().

	If there is no Initialisor then this method will call the pre-reset

	complete method directly allowing the stack to send the HCI reset

	command.

**/

	{

	LOG_FUNC

	// Only re-initialise the stack is the current state is not pre-reset.

	if(iInitState != EPreReset)

		{

		// Initialise the Command Queue

		iCmdController->Initialise();

		iInitState = EPreReset;

		// DeviceClass is cached and retrieved from HCI if not currently

		// set in aDeviceConfig

		iDeviceClass = aDeviceConfig.DeviceClass();

		// Get the Local Name from the Persist storage

		TInt err(iLinkMgrProtocol.SetLocalDeviceName(aDeviceConfig.DeviceName()));

		if (KErrNone != err && KErrNotSupported != err)

			{

			User::Leave(err);

			}

		if (iControllerInitialisor != NULL)

			{

			// see CHCIFacade::McioPreResetCommandComplete

			iControllerInitialisor->MciiPreResetCommand();

			}

		else

			{

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

			// were and it had completed its pre reset phase

			McioPreResetCommandComplete(KErrNone);

			}

		}

	}

CHCIFacade::CHCIFacade(CLinkMgrProtocol& aProtocol)

  : iLinkMgrProtocol(aProtocol),

    iInitState(EIdle),

    iInitialisationError(EFalse)

	{

	LOG_FUNC

	}

CHCIFacade::~CHCIFacade()

	{

	LOG_FUNC

	delete iAFHTimer;

	#ifdef HOSTCONTROLLER_TO_HOST_FLOW_CONTROL

	delete iMBufPool;

	#endif

	delete iCoreHciPlugin;

	if(iCmdController)

		{

		iCmdController->MhcqRemoveAllCommands(*this);

		delete iCmdController;

		}

	iOutstandingCommands.Close();

	delete iHciUtil;

	}

CHctlAclDataFrame* CHCIFacade::NewACLDataFrameL(TUint16 aSize) const

	{

	LOG_FUNC

	return (iDataFramer->MhdfNewAclDataFrameL(aSize));

	}

#ifdef STACK_SCO_DATA

CHctlSynchronousDataFrame* CHCIFacade::NewSynchronousDataFrameL(TUint8 aSCODataLen) const

	{

	LOG_FUNC

	return (iDataFramer->MhdfNewSynchronousDataFrameL(aSCODataLen));

	}

#endif

THCITransportChannel CHCIFacade::HCTLState() const

	{

	LOG_FUNC

	return iHCTLState; // give to muxer

	}

void CHCIFacade::HandlePowerStatusChange(TBTPowerState aStatus)

/**

	This method assumes that the power is actually changing, i.e. from off to on or

	from on to off, and it is the responsibility of the caller, the hctl in non-error

	conditions, to ensure this.

	The only real dangerous transition is from on to on as this would intialise the

	stack even if it is currently in an on state with or without existing state and 

	connections.

**/

	{

	LOG_FUNC

	switch(aStatus)

		{

	case EBTOn:

		// Start-up Bluetooth

		// Avoid from ON to ON

		__ASSERT_DEBUG (iLastPowerState == EBTOff, Panic(EHCIPowerStateError));

		iLastPowerState = aStatus;

		//recovery the channels

		iLinkMgrProtocol.LinkMuxer().ChannelsFree(iHCTLState);

		// Hopefully this should just work it won't rename the device though 

		// since that is persisted

		if (err)

			{

			HandlePowerStatusChange(EBTOff);

			return;

			}

		else

			{

			// Reset the inquiry manager

			iLinkMgrProtocol.InquiryMgr().SetHWState(CBTInquiryMgr::EIdle);

			// Clear debug mode

			iLinkMgrProtocol.SecMan().ClearDebugMode();

			}

		break;

	case EBTOff:

		// Reset the Command Queue

		// Avoid from OFF to OFF

		__ASSERT_DEBUG (iLastPowerState == EBTOn, Panic(EHCIPowerStateError));

		iLastPowerState = aStatus;

		// Determine if we are waiting for a callback from the initialisation plugin

		if ((iInitState == EPreReset) || (iInitState == EReset))

			{

			// cancel initialisation callback if possible

			if (iControllerInitAbortExtension != NULL)

				{

				iControllerInitAbortExtension->MciaeiAbortInitialisation();

				}

			}

		iInitState = EIdle;

		iCmdController->Reset();

		iOutstandingCommands.Reset();

		// Ensure that no command or data messages are output by blocking all channels

		//

		iLinkMgrProtocol.LinkMuxer().ChannelsClosed(KHCITransportAllChannels);

		iLinkMgrProtocol.Error(KErrHardwareNotAvailable);

		// Reset UI

		iLinkMgrProtocol.SetUIConnecting(EFalse);

		iLinkMgrProtocol.SetUINumPhysicalLinks(0);

		// The h/w CoD has been reset, so we need to clear our persistent value, to reflect this

		iLinkMgrProtocol.ClearPendingLocalDeviceSettingsCod();

		// Removes any pending AFH Channel Classification command 

		// and cancels timer.

		// NB This ensures AFH host channel classification command blocking is 

		// not in place if power comes back on.

		iAFHTimer->Reset();

		break;

	default:

		Panic(EHCIUnknownPowerState);

		break;

		}

	// Successfully changed power state

	iLinkMgrProtocol.UpdateLocalDevicePower(aStatus);

	}

TInt CHCIFacade::ChangeMode(TBTLinkMode aMode, THCIConnHandle aConnHandle)

	{

	LOG_FUNC

	TRAPD(err, DoChangeModeL(aMode, aConnHandle));

	return err;

	}

void CHCIFacade::DoChangeModeL(TBTLinkMode aMode, THCIConnHandle aConnHandle)

	{

	LOG_FUNC

	switch (aMode)

		{

		case ESniffMode:

			{

			SniffL(aConnHandle);

			break;

			}

		case EParkMode:

			{

			ParkL(aConnHandle);

			break;

			}

		case EHoldMode:

			{

			HoldL(aConnHandle);

			break;

			}

		case EScatterMode:

		case EActiveMode:

			__ASSERT_DEBUG(0, Panic(EHCICommandBadArgument));

			break;

		}

	}

TInt CHCIFacade::ExitMode(TBTLinkMode aMode, THCIConnHandle aConnHandle)

	{

	LOG_FUNC

	TRAPD(err, DoExitModeL(aMode, aConnHandle));

	return err;

	}

void CHCIFacade::DoExitModeL(TBTLinkMode aMode, THCIConnHandle aConnHandle)

	{

	LOG_FUNC

	switch (aMode)

		{

		case ESniffMode:

			{

			ExitSniffL(aConnHandle);

			break;

			}

		case EParkMode:

			{

			ExitParkL(aConnHandle);

			break;

			}

		// Not possile to prematurely exit hold mode

		default:

			{

			break;

			}

		}

	}

void CHCIFacade::SetupFlowControlL(TFlowControlMode aMode)

/** 

	Set up flow control scheme to be used.

	SetupFlowControlL should only be called once on init because it may leave.

	If TFlowControlMode is chosen to be EFlowControlFromHostControllerOnly or