// Copyright (c) 2007-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 "hctlbcspcontrollermanager.h"

#include "debug.h"
#include "hctlbcsp.h"
#include "bcsputils.h"

#include <bluetooth/hci/controllerstateobserver.h>
#include <bluetooth/hci/hctluartpowermanager.h>

// BlueCore Commands - Must be 18 bytes in length, payload is treated in 16bit units.
//                            |Command |Length |SeqNum |BC Cmd |             Payload                   |
//                            | SetReq |9 units|  N/a  | Reset | Pad                                   |
_LIT8(KBcCmdColdResetCommand, "\x02\x00\x09\x00\x00\x00\x01\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00");
//                            | SetReq |9 units|  N/a  | Halt  | Pad                                   |
_LIT8(KBcCmdColdHaltCommand,  "\x02\x00\x09\x00\x00\x00\x03\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00");


CHCTLBcspControllerManager* CHCTLBcspControllerManager::NewL(CHCTLBcsp& aHCTLBcsp, RBusDevComm& aPort,
		CHCTLUartBase::TPowerControlDetectionMode aPwrCtrlMode)
    {
	LOG_STATIC_FUNC

    CHCTLBcspControllerManager* self = new(ELeave) CHCTLBcspControllerManager(aHCTLBcsp, aPort, aPwrCtrlMode);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
    return self;
    }

CHCTLBcspControllerManager::~CHCTLBcspControllerManager()
    {
	LOG_FUNC

 	delete iPowerDownCallback;
	delete iReadyToResetControllerCallback;
	delete iUartPowerManager;
	}

CHCTLBcspControllerManager::CHCTLBcspControllerManager(CHCTLBcsp& aHCTLBcsp, RBusDevComm& aPort,
		CHCTLUartBase::TPowerControlDetectionMode aPwrCtrlMode)
 :	iPort(aPort),
 	iHCTLBcsp(aHCTLBcsp), 
 	iControllerManagerState(EIdle),
 	iLastPowerRequest(EBTOn),
 	iCurrentPowerState(EBTOn),
	iCurrentTask(ENoTask),
	iPwrCtrlMode(aPwrCtrlMode)
	{
	LOG_FUNC
    }

void CHCTLBcspControllerManager::ConstructL()
	{
	LOG_FUNC

	iColdResetCommand = KBcCmdColdResetCommand();
	iColdHaltCommand = KBcCmdColdHaltCommand();
	
	TCallBack cbHandlePowerDown(HandlePowerDown, this);
	iPowerDownCallback = new(ELeave) CAsyncCallBack(cbHandlePowerDown, CActive::EPriorityStandard);
	
	TCallBack cbHandleReadyToResetController(HandleReadyToResetController, this);
	iReadyToResetControllerCallback = new(ELeave) CAsyncCallBack(cbHandleReadyToResetController, CActive::EPriorityStandard);

	// if the ini file is configured to use CTS line to control the 
	// device's power on/off control than we instantiate iUartPowerManager.
	// otherwise it remains NULL (as implicitly set by CBase base class).
	// So, in the destructor, we can delete it directly. 
	if (iPwrCtrlMode == CHCTLUartBase::EPwrCtrlCTSTimedLow)
		{
		iUartPowerManager = CHCTLUartPowerManager::NewL(*this, iPort);
		iUartPowerManager->Start();
		}
	}


void CHCTLBcspControllerManager::Start()
/*
For future use - called when HCTL is started
*/
	{
	LOG_FUNC
	}

void CHCTLBcspControllerManager::MhupoPowerChange(TInt aError)
	{
	LOG_FUNC

	if (aError == KErrNone)
		{
		// if there is a task underway then the observer will be notified elsewhere
		if (iCurrentTask == ENoTask)
			{
			// unsolicited power change			
			iCurrentPowerState = (iCurrentPowerState == EBTOn) ? EBTOff : EBTOn;
			LOG1(_L8("Unsolicited power change detected, current power state: %d"), iCurrentPowerState);

			if(iObserver)
				{
				iObserver->McsoProcessPowerChange(KErrNone, MControllerStateObserver::EBTFatalChange, iCurrentPowerState);
				}
			}
		}
	else
		{
		// If we get an error from the uart power manager then just log
		// error but do not attempt to restart.
		LOG1(_L8("Error detecting power change: %d"), aError);
		}
	}

TInt CHCTLBcspControllerManager::MhpiGetPower(TBTPowerState& aState)
	{
	if(iCurrentTask != ENoTask)
		//Information will not be reliable
		{
		return KErrInUse;
		}

	aState = iCurrentPowerState;
	return KErrNone;
	}
	
TInt CHCTLBcspControllerManager::MhpiSetPower(TBTPowerState aState)
/*
To be called from outside the class only, for example in response to user request
*/
	{
	TInt rerr = KErrNone;
	
	switch(iCurrentTask)
		{
		case EPowerUp:
		case EPowerDown:
			//If SetPower is called whilst performing a power request error the BT client. 
			//There should only be one!
			rerr = KErrInUse;
			break;
			
		case EControllerReset:
			//Just postpone power request. A power down will be handled when
			//the next link establshment comes in.
			iLastPowerRequest = aState;
			rerr = KErrInUse;
			break;
			
		case ENoTask:
			iLastPowerRequest = aState;
			if(iCurrentPowerState == iLastPowerRequest)
				{
				//Nothing to do - need to return an error to complete synchronously
				//(Do not tell stack.)
				rerr = KErrAlreadyExists;
				}
			else
				{
				rerr = DoSetPower(aState);
				}
			break;
			
		default:
			PANIC(KBcspPanicCat, EInvalidCurrentTask);
		};
	
	return rerr;	
	}
	
TInt CHCTLBcspControllerManager::DoSetPower(TBTPowerState aState)
	{
	switch(aState)
		{
		case EBTOff:
			{
			iHCTLBcsp.WriteBcCmd(iColdHaltCommand); //this should not produce a response
			iPowerDownCallback->CallBack();	//allows asynch callback to BTClient.
			iCurrentTask = EPowerDown;
			iControllerManagerState = EWaiting;
			iHCTLBcsp.Choke();
			}
			break;

		case EBTOn:
			{
			iHCTLBcsp.UnChoke();
			iHCTLBcsp.ResetMuzzled();  // Reset the muzzled parameter of the BT host
			iHCTLBcsp.WriteBcCmd(iColdResetCommand);
			iCurrentTask = EPowerUp;
			iControllerManagerState = EResetHardware;
			}
			break;

		default:
			PANIC(KBcspPanicCat, EUnexpectedPowerState);
			break;
		};
		
	return KErrNone;
	}

void CHCTLBcspControllerManager::HardReset()
	{
	// Only perform reset if the power is on and the controller is
	// not performing another action.
	if(iLastPowerRequest == EBTOn && iCurrentTask == ENoTask)
		{
		/*
		This implementation assumes a dedicated controller reset will be used.
		However we provide an example of how a power cycle reset might be implemented.
		*/
		iReadyToResetControllerCallback->CallBack();//call back will call reset on controller
		iCurrentTask = EControllerReset;
		iControllerManagerState = EWaiting;
		}
	}

/*
	Called when BCSP state reaches 'garrulous'. 
	Controller Manager may not want BCSP to inform the outside world, 
	for example, if it wishes to do a controller reset, and 
	so wishes to manage the controller itself and keep the outside world at bay.
*/
TBool CHCTLBcspControllerManager::BcspLinkEstablished()
	{
	if(iLastPowerRequest == EBTOff)
		/*
		Should only get here if a power off request occurred whilst 
		awaiting this link establishment - in which case abandon
		whatever we were doing and switch power off.
		*/
		{
		DoSetPower(EBTOff);
		return EFalse;
		}

	TBool doTellStack = ETrue;

	switch(iCurrentTask)
		{
		case ENoTask:
			break; //not to do with us
		case EPowerUp:
			{
			doTellStack = DoBcspLinkEstablishedForPowerUp();
			}
			break;
		case EControllerReset:
			{
			doTellStack = DoBcspLinkEstablishedForControllerReset();
			}
			break;
		case EPowerDown:
		default:
			{
	    	__ASSERT_DEBUG(EFalse, PANIC(KBcspPanicCat, EInvalidCurrentTask));
			}
		}
		
	return doTellStack;
	}

/**
	Called when the controller starts trying to establish a BCSP link whilst we
	think a link is established. This state is intentional if the controller manager
	has called a 'ColdReset' command.
*/
TBool CHCTLBcspControllerManager::ExpectedControllerReset()
	{
	return (iControllerManagerState == EResetHardware);
	}

TBool CHCTLBcspControllerManager::PowerOffRequested()
	{
	return (iLastPowerRequest == EBTOff);
	}

void CHCTLBcspControllerManager::ProcessBcCmdEvent(const TDesC8& /*aEvent*/)
	{
	//unlikely to happen - but just drop if it does
	//maybe useful later if more BCCMDs (BlueCore VSCs) are used.
	}
	
TBool CHCTLBcspControllerManager::DoBcspLinkEstablishedForPowerUp()
	{
	__ASSERT_DEBUG(iControllerManagerState == EResetHardware, PANIC(KBcspPanicCat, EUnexpectedControllerMgrState));
	if(iControllerManagerState == EResetHardware)
		{
		if(iObserver)
			{
			iObserver->McsoProcessPowerChange(KErrNone, MControllerStateObserver::EBTFatalChange, EBTOn);
			}
		iCurrentPowerState = EBTOn; 
		iCurrentTask = ENoTask;
		iControllerManagerState = EIdle; //controller reset finished
		}
	return ETrue;
	}
	
TBool CHCTLBcspControllerManager::DoBcspLinkEstablishedForControllerReset()
	{
	TBool doTellStack = ETrue;
	
	switch(iControllerManagerState)
		{
		case EResetBCSP:
			{
			iHCTLBcsp.WriteBcCmd(iColdResetCommand); //should result in callback to CHCTLBcsp::HandlePeerReset
			iControllerManagerState = EResetHardware;
			doTellStack = EFalse;
			}
			break;
		case EResetHardware:
			{
			if(iObserver)
				{
				iObserver->McsoProcessHardResetPhaseChange(KErrNone, MControllerStateObserver::EBTFatalChange, EBTResetComplete);
				}
			iCurrentTask = ENoTask;
			iControllerManagerState = EIdle; //controller reset finished
			}
			break;
		case EIdle:
			break;

		default:
			{
			PANIC(KBcspPanicCat, EUnexpectedControllerMgrState);
			}
		}

	return doTellStack;
	}

/*static*/TInt CHCTLBcspControllerManager::HandlePowerDown(TAny* aThis)
	{
	LOG_STATIC_FUNC
	
	reinterpret_cast<CHCTLBcspControllerManager*>(aThis)->DoHandlePowerDown();
	return KErrNone;
	}

void CHCTLBcspControllerManager::DoHandlePowerDown()
	{
	LOG_FUNC
	
	if(iObserver)
		{
		iObserver->McsoProcessPowerChange(KErrNone, MControllerStateObserver::EBTFatalChange, EBTOff);
		}
	iCurrentPowerState = EBTOff;
	iCurrentTask = ENoTask;
	iControllerManagerState = EIdle;
	}

/*static*/TInt CHCTLBcspControllerManager::HandleReadyToResetController(TAny* aThis)
	{
	LOG_STATIC_FUNC
	
	reinterpret_cast<CHCTLBcspControllerManager*>(aThis)->DoHandleReadyToResetController();
	return KErrNone;
	}

void CHCTLBcspControllerManager::DoHandleReadyToResetController()
	{
	LOG_FUNC
	
	// asynchronous call to tell stack hard reset has started
	LOG(_L8("HCTLUART: ***Hard Reset Started***"));
	if(iObserver)
		{
		iObserver->McsoProcessHardResetPhaseChange(KErrNone, MControllerStateObserver::EBTFatalChange, EBTResetStarted);
		}
	iHCTLBcsp.Reset(); //causes BCSP to re-establish BCSP link (causing call back to CHCLTBcsp::Unchoke())
	iControllerManagerState = EResetBCSP;
	}

void CHCTLBcspControllerManager::McroControllerResetComplete()
	{
	LOG_FUNC
	
	if(iObserver)
		{
		iObserver->McsoProcessHardResetPhaseChange(KErrNone, MControllerStateObserver::EBTFatalChange, EBTResetComplete);
		}
	iCurrentTask = ENoTask;
	iControllerManagerState = EIdle;
	}

void CHCTLBcspControllerManager::McpooPowerOnComplete()
	{
	if(iObserver)
		{
		iObserver->McsoProcessPowerChange(KErrNone, MControllerStateObserver::EBTFatalChange, EBTOn);
		}
	iCurrentTask = ENoTask;
	iControllerManagerState = EIdle;
	}

/**
 Setter for the observer
 @param aObserver A event observer the power man can use to notify power changes
 */
void CHCTLBcspControllerManager::SetObserver(MControllerStateObserver& aObserver)
	{
	iObserver = &aObserver;
	}
