// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// e32\drivers\pbus\spbus.cpp

// 

//

#include <drivers/pbus.h>

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "locmedia_ost.h"

#ifdef __VC32__

#pragma warning(disable: 4127) // disabling warning "conditional expression is constant"

#endif

#include "spbusTraces.h"

#endif

const TInt KPBusSocketThreadPriority=26;

GLDEF_D DMediaChangeBase* TheMediaChanges[KMaxMediaChanges];

GLDEF_D DPBusSocket* TheSockets[KMaxPBusSockets];

GLDEF_D DPBusPsuBase* TheVccs[KMaxPBusVccs];

GLDEF_D DPBusPsuBase* TheVccCores[KMaxPBusVccs]; 

/********************************************

 * Peripheral bus callback

 ********************************************/

EXPORT_C TPBusCallBack::TPBusCallBack()

	:	iSocket(NULL), iFunction(NULL), iIntMask(0), iPtr(NULL)

	{

	OstTraceFunctionEntry0( TPBUSCALLBACK_TPBUSCALLBACK1_ENTRY );

	iNext=NULL;

	OstTraceFunctionExit0( TPBUSCALLBACK_TPBUSCALLBACK1_EXIT );

	}

EXPORT_C TPBusCallBack::TPBusCallBack(TPBusCallBackFn aFunction, TAny* aPtr)

	: iSocket(NULL), iFunction(aFunction), iIntMask(0), iPtr(aPtr)

	{

	OstTraceFunctionEntry0( TPBUSCALLBACK_TPBUSCALLBACK2_ENTRY );

	iNext=NULL;

	OstTraceFunctionExit0( TPBUSCALLBACK_TPBUSCALLBACK2_EXIT );

	}

EXPORT_C TPBusCallBack::TPBusCallBack(TPBusIsr anIsr, TAny* aPtr, TUint anIntMask)

	: iSocket(NULL), iFunction(NULL), iIntMask(anIntMask), iIsr(anIsr), iPtr(aPtr)

	{

	OstTraceFunctionEntry0( TPBUSCALLBACK_TPBUSCALLBACK3_ENTRY );

	iNext=NULL;

	OstTraceFunctionExit0( TPBUSCALLBACK_TPBUSCALLBACK3_EXIT );

	}

EXPORT_C void TPBusCallBack::Remove()

	{

	OstTraceFunctionEntry0( TPBUSCALLBACK_REMOVE_ENTRY );

	TInt irq=NKern::DisableAllInterrupts();

	if (iNext)

		Deque();

	iNext=NULL;

	NKern::RestoreInterrupts(irq);

	OstTraceFunctionExit0( TPBUSCALLBACK_REMOVE_EXIT );

	}

EXPORT_C void TPBusCallBack::SetSocket(TInt aSocket)

	{

	OstTraceFunctionEntryExt( TPBUSCALLBACK_SETSOCKET_ENTRY, this );

	iSocket=TheSockets[aSocket];

	OstTraceFunctionExit1( TPBUSCALLBACK_SETSOCKET_EXIT, this );

	}

/********************************************

 * Media change base class

 ********************************************/

/**

 * Constructor for a DMediaChangeBase object.

 *

 * @param aMediaChangeNum The media change number

 */

EXPORT_C DMediaChangeBase::DMediaChangeBase(TInt aMediaChangeNum)

	:	iMediaChangeNum(aMediaChangeNum),

		iReplyCount(0),

		iDoorOpenDfc(DoorOpenDfcFn,this,Kern::DfcQue1(),1)

	{

	OstTraceFunctionEntryExt( DMEDIACHANGEBASE_DMEDIACHANGEBASE_ENTRY, this );

	}

/**

 * Creates a DMediaChangeBase object.

 * This should be overridden at the media and variant layer to allow

 * interrupts and other media/variant-specific parameters to be initialised.

 *

 * Method should be called post object creation, although could be used to

 * re-initialise parameters.

 *

 * @return KErrNone Default

 */

EXPORT_C TInt DMediaChangeBase::Create()

	{

	return KErrNone;

	}

/**

 * Called from ISR triggered by media change or from 

 * the Peripheral Bus Controller Media Driver context

 * if a media change is being forced.

 *

 * Method adds/enques a media change event on to the door 

 * open DFC queue. If called by PBUS thread then DFC queue 

 * is by-passed and change event is dealt with synchronously.

 *

 * Media change events are platform specific although are 

 * generally related to a media door or slot being opened.

 */

EXPORT_C void DMediaChangeBase::DoorOpenService()

	{

	if (NKern::CurrentContext()==NKern::EInterrupt)

	    {

	    OstTrace0(TRACE_INTERNALS, DMEDIACHANGEBASE_DOOROPENSERVICE, "Interrupt driven asynchronous media change event");

		iDoorOpenDfc.Add();

	    }

	else 

		{

		if (Kern::DfcQue1()->iThread==(NThreadBase *)NKern::CurrentThread()) 	// check if this is being called from PBUS thread

		    {

		    OstTrace0(TRACE_INTERNALS, DMEDIACHANGEBASE_DOOROPENSERVICE2, "Synchronous media change event");

			MediaChangeEvent(ETrue);

		    }

		else

		    {

		    OstTrace0(TRACE_INTERNALS, DMEDIACHANGEBASE_DOOROPENSERVICE3, "Different thread is queueing request, asynchronous media change event");

			iDoorOpenDfc.Enque();

		    }

		}

	}

/**

 * High priority DFC triggered by media change interrupt.

 * 

 * Media changes events are added/enqued by DMediaChangeBase::DoorOpenService().

 * 

 * @param aPtr Pointer to an instantiated class which enqued/added this DFC event

 */

void DMediaChangeBase::DoorOpenDfcFn(TAny* aPtr)

	{

	OstTraceFunctionEntry0( DMEDIACHANGEBASE_DOOROPENDFCFN_ENTRY );

	DMediaChangeBase* pM=(DMediaChangeBase*)aPtr;

	pM->MediaChangeEvent(ETrue);

	OstTraceFunctionExit0( DMEDIACHANGEBASE_DOOROPENDFCFN_EXIT );

	}

/**

 *

 * Notifies sockets of door close event.

 *

 * This function must be called by variant when door close has been detected.

 */

EXPORT_C void DMediaChangeBase::DoorClosedService()

	{

	OstTraceFunctionEntry1( DMEDIACHANGEBASE_DOORCLOSEDSERVICE_ENTRY, this );

	MediaChangeEvent(EFalse);

	OstTraceFunctionExit1( DMEDIACHANGEBASE_DOORCLOSEDSERVICE_EXIT, this );

	}

/**

 * Notifies relevant peripheral bus sockets of door open or close events.

 *

 * @param aDoorOpened  ETrue if door is opened

 *

 * @see DPBusSocket::DPBusSocket

 */

void DMediaChangeBase::MediaChangeEvent(TBool aDoorOpened)

	{

	OstTraceFunctionEntry1( DMEDIACHANGEBASE_MEDIACHANGEEVENT_ENTRY, this );

	__KTRACE_OPT(KPBUS1,Kern::Printf(">DMediaChangeBase(%d)::MediaChangeEvent(%d)",iMediaChangeNum,aDoorOpened));

	OstTraceExt2(TRACE_INTERNALS, DMEDIACHANGEBASE_DMEDIACHANGEBASE, "iMediaChangeNum=%d; aDoorOpened=%d", iMediaChangeNum,aDoorOpened);

	TInt i;

	// notify all sockets affected

	for (i=0; i<KMaxPBusSockets; i++)

		{

		DPBusSocket* pS=TheSockets[i];

		if (pS && pS->iMediaChange==this)

			{

			// Only increment base reply count if actually adding a DFC

			if (!pS->iMediaChangeDfc.Queued())

			    __e32_atomic_add_ord32(&iReplyCount, 1);

			pS->MediaChangeEvent(aDoorOpened);

			}

		}

	OstTraceFunctionExit1( DMEDIACHANGEBASE_MEDIACHANGEEVENT_EXIT, this );

	}

/**

 * To be called by peripheral bus socket derived classes when

 * door open/close event has been processed.

 *

 * @param aDoorOpened   ETrue door opened event processed,

 *                      EFalse door closed event processed

 *

 * @see DPBusSocket::DoorOpenEvent()

 * @see DPBusSocket::DoorCloseEvent()

 */

void DMediaChangeBase::AcknowledgeEvent(TBool aDoorOpened)

	{

	OstTraceFunctionEntryExt( DMEDIACHANGEBASE_ACKNOWLEDGEEVENT_ENTRY, this );

	TInt c = __e32_atomic_tas_ord32(&iReplyCount, 1, -1, 0);

	if (c==1)

		{

		if (aDoorOpened)

			DoDoorOpen();

		else

			DoDoorClosed();

		}

	OstTraceFunctionExit1( DMEDIACHANGEBASE_ACKNOWLEDGEEVENT_EXIT, this );

	}

/********************************************

 * Power supply base class

 ********************************************/

void psuTick(TAny* aPtr)

	{

	OstTraceFunctionEntry0( _PSUTICK_ENTRY );

	DPBusPsuBase* pP=(DPBusPsuBase*)aPtr;

	pP->iPsuDfc.Enque();

	OstTraceFunctionExit0( _PSUTICK_EXIT );

	}

void psuDfc(TAny* aPtr)

	{

	OstTraceFunctionEntry0( _PSUDFC_ENTRY );

	DPBusPsuBase* pP=(DPBusPsuBase*)aPtr;

	pP->DoTickService();

	OstTraceFunctionExit0( _PSUDFC_EXIT );

	}

/**

Constructor for a DPBusPsuBase object.

@param aPsuNum Unique power supply identification number

@param aMediaChangedNum Unique media change identification number

*/

DPBusPsuBase::DPBusPsuBase(TInt aPsuNum, TInt aMediaChangeNum)

	: iPsuNum(aPsuNum), iMediaChangeNum(aMediaChangeNum), iVoltCheckMethod(EPsuChkComparator), iState(EPsuOff),

	iPsuDfc(psuDfc, this, 4),

	iPwrDownCheckFn(DoPwrDownCheck)

	{

	OstTraceFunctionEntryExt( DPBUSPSUBASE_DPBUSPSUBASE_ENTRY, this );

//	iCurrLimited=EFalse;

//	iVoltageSupported=0;

//	iMaxCurrentInMicroAmps=0;

//	iVoltCheckInterval=0;

//	iInactivityCount=0;

//	iNotLockedCount=0;

//	iInactivityTimeout=0;

//	iNotLockedTimeout=0;

	}

void DPBusPsuBase::DoPwrDownCheck(TAny* aPtr)

	{

	OstTraceFunctionEntry0( DPBUSPSUBASE_DOPWRDOWNCHECK_ENTRY );

	DPBusPsuBase& self = *static_cast<DPBusPsuBase*>(aPtr);

	self.PwrDownCheck();

	OstTraceFunctionExit0( DPBUSPSUBASE_DOPWRDOWNCHECK_EXIT );

	}

/**

Initialises a DPBusPsuBase object.

Sets object information based on hardware variant PSU inforamtion.

Calls DoCreate to initialise the PSU.

@return Standard Symbian OS error code.

@see DPBusPsuBase::PsuInfo()

@see DPBusPsuBase::DoCreate()

*/

TInt DPBusPsuBase::Create()

	{

	OstTraceFunctionEntry1( DPBUSPSUBASE_CREATE_ENTRY, this );

	TPBusPsuInfo pi;

	PsuInfo(pi);

	iVoltageSupported=pi.iVoltageSupported;

	iMaxCurrentInMicroAmps=pi.iMaxCurrentInMicroAmps;

	iVoltCheckInterval=pi.iVoltCheckInterval;

	iVoltCheckMethod=pi.iVoltCheckMethod;

	iInactivityTimeout=pi.iInactivityTimeOut;

	iNotLockedTimeout=pi.iNotLockedTimeOut;

	TInt r=DoCreate();

	if (r!=KErrNone)

	    {

		OstTraceFunctionExitExt( DPBUSPSUBASE_CREATE_EXIT1, this, r );

		return r;

	    }

	iPsuDfc.SetDfcQ(&iSocket->iDfcQ);

	OstTraceFunctionExitExt( DPBUSPSUBASE_CREATE_EXIT2, this, KErrNone );

	return KErrNone;

	}

/**

Initialises the power supply unit.

The function is provided by the hardware variant layer, and needs to initialise 

interrupts and other variant-specific parameters.

The default implementation returns KErrNone.

@return KErrNone

*/

EXPORT_C TInt DPBusPsuBase::DoCreate()

	{

	OstTraceFunctionEntry1( DPBUSPSUBASE_DOCREATE_ENTRY, this );

	TInt r = KErrNone;

	OstTraceFunctionExitExt( DPBUSPSUBASE_DOCREATE_EXIT, this, r );

	return r;

	}

/**

Reset (turn off) the power supply unit.

Sets PSU state to EPsuOff.

*/

void DPBusPsuBase::Reset()

	{

	OstTraceFunctionEntry1( DPBUSPSUBASE_RESET_ENTRY, this );

	SetState(EPsuOff);

	iCurrLimited=EFalse;

	OstTraceFunctionExit1( DPBUSPSUBASE_RESET_EXIT, this );

	}

/**

Checks whether this PSU is powering a bus containing

a locked device, i.e. one that is recognised and in use by a client.

The function is provided at the media layer, could be used to ensure power is not

removed whilst media is locked or some other media specific power management activatity.

The default implementation just returns EFalse.

@return EFalse

*/

EXPORT_C TBool DPBusPsuBase::IsLocked()

	{

	return EFalse;

	}

/**

Controls the power supply state.

@param aState A TPBusPsuState enumeration specifying the required state

			 (EPsuOnFull, EPsuOff, EPsuOnCurLimit)

@return KErrNone if successful, otherwise one of the other system wide error codes.

@see TPBusPsuState

@see DPBusPsuBase::DoSetState()

*/

EXPORT_C TInt DPBusPsuBase::SetState(TPBusPsuState aState)

	{

	OstTraceFunctionEntry1( DPBUSPSUBASE_SETSTATE_ENTRY, this );

	TInt r=KErrGeneral;

	if (aState==EPsuOff)

		{

		iTickLink.Cancel(); // No point in having the 1 second tick running while the PSU is off

		}

	else

		{

		// Start the 1 second tick to monitor for inactivity, not in use and PSU level checking

		iTickLink.Cancel();

		iTickLink.Periodic(KPBusPsuTickInterval,psuTick,this);

		}

	// Don't turn the PSU back on if it has current limited since the last reset event 

	iInactivityCount=0;

	iNotLockedCount=0;

	if (aState==EPsuOff || !iCurrLimited)

		{

		DoSetState(aState);

		iState=aState;

		r=KErrNone;

		}

	__KTRACE_OPT(KPBUS2,Kern::Printf("<Psu(%d):Set(%d)-%d",iPsuNum,aState,r));

	OstTraceExt3(TRACE_INTERNALS, DPBUSPSUBASE_SETSTATE, "iPsuNum=%d; aState=%d; retval=%d", iPsuNum, (TInt) aState, r);

	OstTraceFunctionExit1( DPBUSPSUBASE_SETSTATE_EXIT, this );

	return r;

	}

/**

Check the voltage level of the power supply unit is as expected.

This method is called every PSU tick.

@param aCheckStatus Power check status in which voltage check can be performed (e.g. KPsuChkOnPwrUp).

@return KErrNone Voltage checking has been performed.

        KErrNotSupported Voltage checking is not supported by the hardware variant.

@see KPsuChkOnPwrUp       

@see KPsuChkWhileOn

@see DPBusPsuBase::DoTickService()

@see DPBusPsuBase::DoCheckVoltage()

*/

TInt DPBusPsuBase::CheckVoltage(TUint aCheckStatus)

	{

	OstTraceFunctionEntryExt( DPBUSPSUBASE_CHECKVOLTAGE_ENTRY, this );

	// Check that voltage checking is in order at this time

	if (

		(aCheckStatus&iVoltCheckInterval) &&

		((aCheckStatus&KPsuChkOnPwrUp) || ((aCheckStatus&KPsuChkWhileOn)&&iState==EPsuOnFull))

	   )

		{

		DoCheckVoltage();

		OstTraceFunctionExitExt( DPBUSPSUBASE_CHECKVOLTAGE_EXIT, this, KErrNone );

		return KErrNone;

		}

	OstTraceFunctionExitExt( DPBUSPSUBASE_CHECKVOLTAGE_EXIT2, this, KErrNotSupported );

	return KErrNotSupported;

	}

/**

Reports the result of the voltage check.

The function is called by the variant implementation of DoCheckVoltage() 

to report the result.

Reporting a result of KErrGeneral (to indicate a failure) will result in a 

call to DPBusSocket::PsuFault(), otherwise report KErrNone to indicate a pass

and KErrNotReady if the voltage check was not completed.

@param anError System wide error code

@see DPBusPsuBase::DoCheckVoltage()

@see DPBusSocket::PsuFault()

*/

EXPORT_C void DPBusPsuBase::ReceiveVoltageCheckResult(TInt anError)

	{

	OstTraceFunctionEntryExt( DPBUSPSUBASE_RECEIVEVOLTAGECHECKRESULT_ENTRY, this );

//	__KTRACE_OPT(KPBUS1,Kern::Printf("DPBusPsuBase(%d)::ReceiveVoltageCheckResult(%d)",iPsuNum,anError));

	OstTraceExt2(TRACE_INTERNALS, DPBUSPSUBASE_RECEVIVEVOLTAGECHECKRESULT,"iPsuNum=%d; ReceiveVoltageCheckResult=%d",iPsuNum,anError );

	if (anError==KErrGeneral)

		{

		SetCurrLimited();

		iSocket->PsuFault(KErrCorrupt);

		}

	OstTraceFunctionExit1( DPBUSPSUBASE_RECEIVEVOLTAGECHECKRESULT_EXIT, this );

	}

/**

Get the current power supply unit status

@return PSU status.

@see TPBusPsuStatus

*/

TPBusPsuStatus DPBusPsuBase::Status()

	{

	OstTraceFunctionEntry1( DPBUSPSUBASE_STATUS_ENTRY, this );

	if (iCurrLimited)

	    {

		OstTraceFunctionExit1( DPBUSPSUBASE_STATUS_EXIT1, this );

		return(EPsuStatError);

	    }

	else

	    {

	    OstTraceFunctionExit1( DPBUSPSUBASE_STATUS_EXIT2, this );

		return( (iState==EPsuOff) ? EPsuStatOff : EPsuStatOn );

	    }

	}

/**

Checks if power supply unit can be turned off.

@see DPBusPsuBase::DoTickService()

*/

void DPBusPsuBase::PwrDownCheck()

	{

OstTraceFunctionEntry1( DPBUSPSUBASE_PWRDOWNCHECK_ENTRY, this );

	if (

		(iNotLockedTimeout&&!IsLocked()&&++iNotLockedCount>iNotLockedTimeout) ||

		(iInactivityTimeout&&++iInactivityCount>iInactivityTimeout)

	   )

			iSocket->PsuTimeout();

	OstTraceFunctionExit1( DPBUSPSUBASE_PWRDOWNCHECK_EXIT, this );

	}

/**

Services the Pc Card Tick (called in timer thread).

*/

EXPORT_C void DPBusPsuBase::DoTickService()

	{

	OstTraceFunctionEntry1( DPBUSPSUBASE_DOTICKSERVICE_ENTRY, this );

	if (iPwrDownCheckFn)

		(*iPwrDownCheckFn)(this);	

	CheckVoltage(KPsuChkWhileOn);	// Check voltage level