// 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 "ControllerInitialisationPluginImpl.h"
#include "ControllerInitialisationCmndParser.h"
#include "tiinitialisorutils.h"

#include <bluetooth/hci/vendordebugcommand.h>
#include <bluetooth/hci/controllerinitialisationobserver.h>
#include <bluetooth/hcicommandqueue.h>

#include <bluetooth/hci/readlocalversioninfocommand.h>

#include <bluetooth/hci/commandcompleteevent.h>
#include <bluetooth/hci/readlocalversioninfocompleteevent.h>
#include <bluetooth/hci/vendordebugcompleteevent.h>

#include <bluetooth/hci/hctlconfiginterface.h>
#include <bluetooth/hci/corehci.h>

#include <bluetooth/logger.h>

#include <es_sock.h>

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

_LIT(KScriptPath, "z:\\private\\101f7989\\Bluetooth\\");
_LIT(KScriptPathFileFormat, "%Stiinit_%d.%d.%d.bts");

const TUint16 KHciVSUpdateUartHCIBaudRate = 0xFF36;
const TUint16 KHciVSEnableSleepMode = 0xFF0C;
const TUint16 KHciVSSleepModeConfig = 0xFD0C; // BRF6300 version
const TUint16 KHciVSSetBDAddr = 0xFC06;

const TUint16 KProjectTypeMask = 0x7C00;	// mask needed to extract the project type
const TUint16 KProjectTypeShift = 10;		// shift needed to extract the project type
const TUint16 KMinorVersionMask = 0x007F;
const TUint16 KMajorVersionMask = 0x0380;	// mask needed to extract the major version
const TUint16 KMajorVersionShift = 7;		// shift needed to extract the major version
const TUint16 KBit15Mask = 0x8000;
const TUint16 KBit15Shift = 12;				// shift needed to move bit15 to bit3
											// (it will be pre-pended as an extra hi-bit for
											// the 3-bit major version number)


/*static*/ CControllerInitialisationPluginImpl* CControllerInitialisationPluginImpl::NewL()
	{
	LOG_STATIC_FUNC

	CControllerInitialisationPluginImpl* self = new (ELeave) CControllerInitialisationPluginImpl();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}
	
void CControllerInitialisationPluginImpl::ConstructL()
	{
	LOG_FUNC

	// Add Async Callbacks
	TCallBack preResetCallBack(AsyncCallBackForPreReset, this);
	iAsyncCallBackForPreReset = new (ELeave)CAsyncCallBack(preResetCallBack, CActive::EPriorityStandard);
	TCallBack postResetCallBack(AsyncCallBackForPostReset, this);
	iAsyncCallBackForPostReset = new (ELeave)CAsyncCallBack(postResetCallBack, CActive::EPriorityStandard);

	iSleepDisableTimer = CSleepDisableTimer::NewL(*this);
	}
	
CControllerInitialisationPluginImpl::CControllerInitialisationPluginImpl()
  : iInitState(EIdle)
	{
	LOG_FUNC
	}

CControllerInitialisationPluginImpl::~CControllerInitialisationPluginImpl()
	{
	LOG_FUNC

	delete iCommandParser;
	// Delete async CallBacks.	If running, these should be cancelled by the
	// d'tor of CAsyncOneShot.
	delete iAsyncCallBackForPreReset;
	delete iAsyncCallBackForPostReset;		
	delete iSleepDisableTimer;
	}

	
/*virtual*/ TAny* CControllerInitialisationPluginImpl::Interface(TUid aUid)
	{	
	LOG_FUNC

	TAny* ret = NULL;
	switch(aUid.iUid)
		{
		case KControllerInitialisationInterfaceUid:
			ret = reinterpret_cast<TAny*>(static_cast<MControllerInitialisationInterface*>(this));
			break;

		default:
			break;
		};
	return ret;
	}

// Static async CallBack methods.
/*static*/ TInt CControllerInitialisationPluginImpl::AsyncCallBackForPreReset(TAny* aInitPlugin)
	{
	LOG_STATIC_FUNC

	CControllerInitialisationPluginImpl* initPlugin = static_cast<CControllerInitialisationPluginImpl*>(aInitPlugin);
	initPlugin->DoPreReset();
	return EFalse;	// Don't call back any more.
	}
	
/*static*/ TInt CControllerInitialisationPluginImpl::AsyncCallBackForPostReset(TAny* aInitPlugin)
	{
	LOG_STATIC_FUNC

	CControllerInitialisationPluginImpl* initPlugin = static_cast<CControllerInitialisationPluginImpl*>(aInitPlugin);
	initPlugin->DoPostReset();
	return EFalse;	// Don't call back any more.
	}

void CControllerInitialisationPluginImpl::DoPreReset()
	{
	LOG_FUNC

	iInitState = EIdle;
	
	// Inform stack that we have finished	
	iControllerInitialisationObserver->McioPreResetCommandComplete(KErrNone);
	}

void CControllerInitialisationPluginImpl::DoPostReset()
	{
	LOG_FUNC

	// Request local version information.
	CReadLocalVersionInfoCommand* cmd = NULL;
	TRAPD(err, cmd = CReadLocalVersionInfoCommand::NewL());
	if(err == KErrNone)
		{
		TRAP(err, iHCICommandQueue->MhcqAddInitCommandL(cmd, *this));
		}
		
	if(err != KErrNone)
		{
		// Inform the stack of the initialisation status.
		iControllerInitialisationObserver->McioPostResetCommandComplete(err);
		}
	iInitState = EWaitLocalDeviceInfo;
	}

/*virtual*/ void CControllerInitialisationPluginImpl::MciiPreResetCommand()
	{
	LOG_FUNC

	__ASSERT_DEBUG(iControllerInitialisationObserver, PANIC(KTiControllerInitialisorPanic, ENullInitialisationObserver));

	// Use async callback
	iAsyncCallBackForPreReset->CallBack();	
	}

/*virtual*/ void CControllerInitialisationPluginImpl::MciiPostResetCommand()
	{	
	LOG_FUNC

	__ASSERT_DEBUG(iControllerInitialisationObserver, PANIC(KTiControllerInitialisorPanic, ENullInitialisationObserver));
	
	// Use async callback
	iAsyncCallBackForPostReset->CallBack();
	}

/*virtual*/ void CControllerInitialisationPluginImpl::MciiSetHCICommandQueue(MHCICommandQueue& aHCICommandQueue)
	{
	LOG_FUNC

	__ASSERT_DEBUG(iHCICommandQueue == 0, PANIC(KTiControllerInitialisorPanic, EHciCommandQueueOverwritten));
	iHCICommandQueue = &aHCICommandQueue;
	}

/*virtual*/ void CControllerInitialisationPluginImpl::MciiSetControllerInitialisationObserver(MControllerInitialisationObserver& aObserver)
	{
	LOG_FUNC

	__ASSERT_DEBUG(iControllerInitialisationObserver == 0, PANIC(KTiControllerInitialisorPanic, EInitialisationObserverOverwritten));
	iControllerInitialisationObserver = &aObserver;
	}

/*virtual*/ void CControllerInitialisationPluginImpl::MciiSetCoreHci(MCoreHci& aCoreHci)
	{
	LOG_FUNC

	__ASSERT_DEBUG(iCoreHci == 0, PANIC(KTiControllerInitialisorPanic, ECoreHciOverwritten));
	iCoreHci = &aCoreHci;
	}

void CControllerInitialisationPluginImpl::SendNextScriptFileCommandL()
	{
	LOG_FUNC

	// Create default Vendor command.
	CVendorDebugCommand* cmd = CVendorDebugCommand::NewL(KVendorDebugOGF);
	CleanupStack::PushL(cmd);
	LEAVEIFERRORL(iCommandParser->GetNextVendorCommand(*cmd));

	// Make any command specific changes.
	switch(cmd->Opcode())
		{
		case KHciVSUpdateUartHCIBaudRate:
			{
			iDesiredBaudRate = LittleEndian::Get32(cmd->Command().Ptr());
			}
			break;

		case KHciVSSetBDAddr:
			{
			SetLocalBDAddr(cmd->Command());
			}
			break;

		default:
			// Nothing to do.
			break;			
		};
		
		
	// Send the command.
	CleanupStack::Pop();
	iHCICommandQueue->MhcqAddInitCommandL(cmd, *this);
	}

void CControllerInitialisationPluginImpl::MhcqcCommandEventReceived(const THCIEventBase& aEvent,
																	const CHCICommandBase* /*aRelatedCommand*/)
	{
	LOG_FUNC

	if (aEvent.EventCode() == ECommandCompleteEvent)
		{
		// Switch on the opcode.
		THCICommandCompleteEvent& event = THCICommandCompleteEvent::Cast(aEvent);
		switch(event.CommandOpcode())
			{
			case KReadLocalVersionInfoOpcode:
				{
				TReadLocalVersionInfoCompleteEvent& lvEvent = TReadLocalVersionInfoCompleteEvent::Cast(event);
				HandleReadLocalVersionInfoCompleteEvent(lvEvent);
				}
				break;

			default:
				// Check for VS commands.
				if((event.CommandOpcode() & KVendorDebugOGF) == KVendorDebugOGF)
					{
					TVendorDebugCompleteEvent& vEvent = TVendorDebugCompleteEvent::Cast(event);
					HandleVendorSpecificCompleteEvent(vEvent);
					}						
				break;	
			}
		}
	}

void CControllerInitialisationPluginImpl::HandleReadLocalVersionInfoCompleteEvent(const TReadLocalVersionInfoCompleteEvent& aEvent)
	{
	LOG_FUNC
	
	TInt err = KErrNone;				// innocent until proved guilty
	
	if (iInitState == EWaitLocalDeviceInfo)
		{
		if (aEvent.ErrorCode() != EOK)
			{
			err = KHCIErrorBase - aEvent.ErrorCode();
			}
		else
			{
			iSubVersion = aEvent.LMPSubversion();
			
			// Attempt to open the script file.
			TFileName fileName;
			fileName.Format(KScriptPathFileFormat,
							&KScriptPath,
			                ((iSubVersion & KProjectTypeMask) >> KProjectTypeShift),
			                ((iSubVersion & KMajorVersionMask) >> KMajorVersionShift) | ((iSubVersion & KBit15Mask) >> KBit15Shift),
			                (iSubVersion & KMinorVersionMask));

			TRAP(err, iCommandParser = CCommandParser::NewL(fileName));
			}
		if(err == KErrNone)
			{
			iSleepDisableTimer->Start();
			iInitState = EWaitForSleepTimerExpiry;
			}
		else
			{
			iControllerInitialisationObserver->McioPostResetCommandComplete(err);
			iInitState = EIdle;
			}
		}
	}

void CControllerInitialisationPluginImpl::HandleVendorSpecificCompleteEvent(const TVendorDebugCompleteEvent& aEvent)
	{
	LOG_FUNC

	switch(iInitState)
		{
		case ESendScriptCommands:
			{
			switch(aEvent.CommandOpcode())
				{
				case KHciVSUpdateUartHCIBaudRate:
					{
					MHctlConfigInterface* configIf = static_cast<MHctlConfigInterface*>(iCoreHci->MchHctlPluginInterface(TUid::Uid(KHctlConfigInterfaceUid)));
					__ASSERT_DEBUG(configIf, PANIC(KTiControllerInitialisorPanic, EConfigInterfaceNull));

					TInt err = configIf->MhciUpdateBaudRate(iDesiredBaudRate);
					if(err != KErrNone)
						{
						iControllerInitialisationObserver->McioPostResetCommandComplete(err);
						}
					}
					break;

				case KHciVSEnableSleepMode:
				case KHciVSSleepModeConfig:
					{
					SetSleepProtocol(EFalse);
					}
					break;
					
				default:
					break;
				};

			// Send the next command.
			TRAPD(err, SendNextScriptFileCommandL());
			// End of File is not an error that needs to be reported.
			if(err == KErrEof)
				{
				// All commands have been sent.
				iControllerInitialisationObserver->McioPostResetCommandComplete(KErrNone);
				}
			else if(err != KErrNone)
				{
				// Inform the stack of the initialisation status.
				iControllerInitialisationObserver->McioPostResetCommandComplete(err);
				}
			}
			break;
			
		case EWaitSleepDisableCompleteEvent:
			{
			TUint16 opcode = aEvent.CommandOpcode();
			if(opcode == KHciVSEnableSleepMode ||
			   opcode == KHciVSSleepModeConfig)
				{
				SetSleepProtocol(EFalse);

				// Response received.  Start sending commands from the script file.
				iInitState = ESendScriptCommands;
				
				TRAPD(err, SendNextScriptFileCommandL());
				// End of File is not an error that needs to be reported.
				if(err == KErrEof)
					{
					// All commands have been sent.
					iControllerInitialisationObserver->McioPostResetCommandComplete(KErrNone);
					}
				else if(err != KErrNone)
					{
					// Inform the stack of the initialisation status.
					iControllerInitialisationObserver->McioPostResetCommandComplete(err);
					}
				}
			}
			break;
		};
	}
	
void CControllerInitialisationPluginImpl::MhcqcCommandErrored(TInt aErrorCode,
					  										  const CHCICommandBase* /*aCommand*/)
	{
	LOG_FUNC

	switch(iInitState)
		{
		case EWaitLocalDeviceInfo:
		case ESendScriptCommands:
			{
			// Inform the stack of the initialisation failure.
			iControllerInitialisationObserver->McioPostResetCommandComplete(aErrorCode);
			}
			break;

		default:
			PANIC(KTiControllerInitialisorPanic, EInvalidInitialisorState);
			break;
		};
	}


void CControllerInitialisationPluginImpl::SleepDisableTimerExpired()
	{
	LOG_FUNC

	TInt err = KErrNone;
	CVendorDebugCommand* cmd = NULL;
	SetSleepProtocol(EFalse);
	
	// Send the sleep disable command.
	if(((iSubVersion & KProjectTypeMask) >> KProjectTypeShift) >= 4)
		{
		TRAP(err, cmd = CVendorDebugCommand::NewL(KHciVSSleepModeConfig));
		if(err == KErrNone)
			{
			// Populate the command.
			TDes8& cmdData = cmd->Command();
			cmdData.FillZ(9);
			cmdData[3] = 0xff;
			cmdData[4] = 0xff;
			cmdData[5] = 0xff;
			}
		}
	else
		{
		TRAP(err, cmd = CVendorDebugCommand::NewL(KHciVSEnableSleepMode));
		if(err == KErrNone)
			{
			// Populate the command.
			TDes8& cmdData = cmd->Command();
			cmdData.FillZ(9);
			}
		}

	if(err == KErrNone)
		{
		TRAP(err, iHCICommandQueue->MhcqAddInitCommandL(cmd, *this));
		}
		
	if(err != KErrNone)
		{
		// Inform the stack of the initialisation status.
		iControllerInitialisationObserver->McioPostResetCommandComplete(err);
		}
	iInitState = EWaitSleepDisableCompleteEvent;
	}

void CControllerInitialisationPluginImpl::SetLocalBDAddr(TDes8& /*aVSCommandData*/) const
	{
	LOG_FUNC

	// Update the address from the script file if required.
	}

void CControllerInitialisationPluginImpl::SetSleepProtocol(TBool /*aEnabled*/)
	{
	LOG_FUNC

	// Adjust the controller sleep protocol.
	}
	
//
//
CSleepDisableTimer* CSleepDisableTimer::NewL(MSleepDisableTimerEventObserver& aTimerObserver)
	{
	LOG_STATIC_FUNC

   	CSleepDisableTimer* self = new (ELeave) CSleepDisableTimer(aTimerObserver);
   	CleanupStack::PushL(self);
   	self->ConstructL();
   	CleanupStack::Pop(self);
   	return self;
	}

void CSleepDisableTimer::ConstructL()
	{
	LOG_FUNC

   	CTimer::ConstructL();
   	CActiveScheduler::Add(this);
	}

CSleepDisableTimer::CSleepDisableTimer(MSleepDisableTimerEventObserver& aTimerObserver)
  : CTimer(EPriorityStandard),
    iTimerObserver(aTimerObserver)
	{
	LOG_FUNC
	}

void CSleepDisableTimer::Start()
	{
	LOG_FUNC

	if(!IsActive())
		{
		After(KSleepDisableTimerDuration);
		}
	}
	
void CSleepDisableTimer::RunL()
	{
 	LOG_FUNC

  	iTimerObserver.SleepDisableTimerExpired();
   	}