/*

* Copyright (c) 2008-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:  

* naviengine_assp\gpio.cpp

* NaviEngine implementation of the MHA GPIO class

*

*/

#include <naviengine_priv.h>

#include <gpio.h>

const TInt32		KHwGpioPinMax		= 31;

const TInt32		KHwGpioEdgeRising	= 0x0;

const TInt32		KHwGpioEdgeFalling	= 0x1;

const TInt32		KHwGpioEdgeBoth		= 0x2;

const TInt32		KHwGpioLevelLow		= 0x3;

const TInt32		KHwGpioLevelHigh	= 0x4;

const  TInt32		KGpioDebounceInterval = 1; // (in ticks)

const  TInt32		KGpioMaxRetries = 8;

class GpioPin

	{

public:

	GPIO::TGpioMode	iMode;

   	TGpioIsr		iIsr;

	TAny *			iPtr;

	TInt			iDebounce;

	};

static GpioPin	GpioPins[KHwGpioPinMax+1];

static TInt32	GpioInterruptId;

#ifdef __SMP__

const  TInt32		KGpioLockOrder = TSpinLock::EOrderGenericIrqLow2;

static TSpinLock	GpioSpinLock(KGpioLockOrder);

#endif

inline TInt GpioLock();

inline void GpioUnlock(TInt irq);

/**

Calculate 16-bit device pin Id from 32-bit pin Id. Use DeviceId() to 

get device Id.

@param   aId         32-bit pin Id

@return  16-bit device specific pin Id

*/

static inline TUint16 DevicePinId(TInt aId)

    {return static_cast<TUint16>(aId & 0x0000FFFF);}

//Commented out to satisfy compiler(as method is not used in the code) but can  

//be usefull later

/**

Calculate and return GPIO device Id(either SOC or one of the extenders)

defined in TGpioBaseId from the 32-bit pin Id

@param   aId         32-bit pin Id

@return

   - EInternalId              SOC GPIO 

   - EExtender0-15            GPIO extenders from 0-15

static inline GPIO::TGpioBaseId ExtenderId(TInt aId)

    {return static_cast<GPIO::TGpioBaseId>((aId & 0xFFFF0000));}

*/

//Commented out to satisfy compiler(as method is not used in the code) but can  

//be usefull later

/**

Generate 32-bit pin Id from the device Id and device specific 16-bit 

pin Id.

@param   aExtenderId     Device Id is defined in TGpioBaseId

@param   aPinId          16-bit device pin Id

return   32-bit pin Id  

static inline TInt Id(GPIO::TGpioBaseId aExtenderId, TUint16 aPinId)

    {return static_cast<TInt>(aExtenderId |aPinId);}

*/

//Commented out to satisfy compiler(as method is not used in the code) but can  

//be usefull later

/**

Find index in extender GPIO device table.

@param   aExtenderId     Extender Id is defined in TGpioBaseId

@return  singned 32-bit integer index device, possible value 

        from 0 to 15

static TInt DeviceIndex(GPIO::TGpioBaseId aExtenderId)

    {

    TUint16 val = (TUint16)((aExtenderId & 0xFFFF0000) >> 16);

    if(val == 0) return GPIO::EInternalId;

    //The algorithm steps througth the value until first non-zero bit is

    //found.

    //

    TInt index = 0;

    if(val & 0xFF00) {index  = 8; val = val >> 8;} // 2 x 8-bits

    if(val & 0x00F0) {index += 4; val = val >> 4;} // 2 x 4-bits

    if(val & 0x000C) {index += 2; val = val >> 2;} // 2 x 2 bits

    if(val & 0x0002) {index += 1; val = val >> 1;} // 2 x 1 bits

    return index;

    }

*/

//Commented out to satisfy compiler(as method is not used in the code) but can  

//be usefull later

/**

Find index in extender GPIO device table.

@param   aId    32-bit GPIO pin Id

@return  singned 32-bit integer index device, possible value 

         from 0 to 15

static TInt DeviceIndex(TInt aId){return DeviceIndex(ExtenderId(aId));}

*/

/**

GPIO interrupt handler

Takes a generic argument (TAny*)

*/

void GpioIsrDispatch(TAny *aPtr)

	{

	GpioPin	*pins = (GpioPin *)aPtr;

	TInt irq = GpioLock();

	TUint32 interrupt = AsspRegister::Read32(KHwRwGpio_Int);

	TUint32 enabled = AsspRegister::Read32(KHwRwGpio_Int_Enable);

	TUint32	masked = interrupt & enabled;

	for (TInt i = 0; i <= KHwGpioPinMax; i++)

		{

		if ((masked & 0x1) && (pins[i].iIsr != NULL))

			{

			(*pins[i].iIsr)(pins[i].iPtr);

			}

		masked >>= 1;

		}

	Interrupt::Clear(GpioInterruptId);

	GpioUnlock(irq);

	}

#include "gpio.inl"

//

// work out debounced state

//

TInt GetDebouncedState(TInt aId, TUint32 &aVal)

	{

    TUint16   pinId = DevicePinId(aId);

	TInt	debounceCount = GpioPins[pinId].iDebounce/KGpioDebounceInterval;

	TInt	count = 0;

	TInt	retries = debounceCount*KGpioMaxRetries;

	TUint	lastState = AsspRegister::Read32(KHwRoGpio_Port_Value);

	TUint	state = lastState;

	for (count = 0; count < debounceCount && retries > 0; count ++)

		{

		NKern::Sleep(KGpioDebounceInterval);

		state = AsspRegister::Read32(KHwRoGpio_Port_Value);

		if ((state & 1<<pinId) != (lastState & 1<<pinId))

			{

			// state has changed so reset count and lastState

			lastState = AsspRegister::Read32(KHwRoGpio_Port_Value);

			count = 0;

			retries--;

			}

		}

	if (retries == 0)

		{

		// too many retries

		return KErrTimedOut;

		}

	aVal = state;

	return KErrNone;

	}

EXPORT_C TInt GPIO::SetPinMode

	(

	TInt      aId,

   	TGpioMode aMode

	)

	{

    TUint16 pinId = DevicePinId(aId);

	// the chip doesn't support modes, so just store it

	if (pinId > KHwGpioPinMax)

		{

		return KErrArgument;

		}

	__e32_atomic_store_rel32(&GpioPins[pinId].iMode, aMode);

	return KErrNone;

	}

EXPORT_C TInt GPIO::GetPinMode

	(

	TInt        aId,

   	TGpioMode & aMode

	)

	{

    TUint16 pinId = DevicePinId(aId);

	// the chip doesn't support modes, so just return what we stored earlier

	if (pinId > KHwGpioPinMax)

		{

		return KErrArgument;

		}

	aMode = (TGpioMode) __e32_atomic_load_acq32(&GpioPins[pinId].iMode);

	return KErrNone;

	}

EXPORT_C TInt GPIO::SetPinDirection

	(

	TInt           aId,

   	TGpioDirection aDirection

	)

	{

    TUint16 pinId = DevicePinId(aId);

	// tristate not supported

	if (pinId > KHwGpioPinMax || aDirection == ETriStated)

		{

		return KErrArgument;

		}

	// port enabled means output, disabled means input

	if (aDirection == EInput)

		{

		AsspRegister::Write32(KHwWoGpio_Port_Control_Disable, 1<<pinId);

		}

	else

		{

		AsspRegister::Write32(KHwRwGpio_Port_Control_Enable, 1<<pinId);

		}

	return KErrNone;

	}

EXPORT_C TInt GPIO::GetPinDirection

	(

	TInt             aId,

   	TGpioDirection & aDirection

	)

	{

    TUint16 pinId = DevicePinId(aId);

	if (pinId > KHwGpioPinMax)

		{

		return KErrArgument;

		}

	// port enabled means output, disabled means input

	TUint enabled = AsspRegister::Read32(KHwRwGpio_Port_Control_Enable);

	if (enabled & 1<<pinId)

		{

		aDirection = EOutput;

		}

	else

		{

		aDirection = EInput;

		}

	return KErrNone;

	}

EXPORT_C TInt GPIO::SetPinBias

	(

	TInt      aId,

   	TGpioBias /*aBias*/

	)

	{

    TUint16 pinId = DevicePinId(aId);

	// pin bias not supported

	if (pinId > KHwGpioPinMax)

		{

		return KErrArgument;

		}

	return KErrNotSupported;

	}

EXPORT_C TInt GPIO::GetPinBias

	(

	TInt        aId,

   	TGpioBias& /*aBias*/

	)

	{

    TUint16 pinId = DevicePinId(aId);

	// pin bias not supported

	if (pinId > KHwGpioPinMax)

		{

		return KErrArgument;

		}

	return KErrNotSupported;

	}

EXPORT_C TInt GPIO::SetPinIdleConfigurationAndState

	(

	TInt        aId,

   	TInt		/*aConf*/

	)

	{

    TUint16 pinId = DevicePinId(aId);

	// pin idle configuration and state not supported

	if (pinId > KHwGpioPinMax)

		{

		return KErrArgument;

		}

	return KErrNotSupported;

	}

EXPORT_C TInt GPIO::GetPinIdleConfigurationAndState

	(

	TInt        aId,

   	TInt	  & /*aBias*/

	)

	{

    TUint16 pinId = DevicePinId(aId);

	// pin idle configuration and state not supported

	if (pinId > KHwGpioPinMax)

		{

		return KErrArgument;

		}

	return KErrNotSupported;

	}

EXPORT_C TInt GPIO::BindInterrupt

	(

	TInt     aId,

   	TGpioIsr aIsr,

   	TAny *   aPtr

	)

	{

    TUint16 pinId = DevicePinId(aId);

	if (pinId > KHwGpioPinMax || aIsr == NULL)

		{

		return KErrArgument;

		}

	TInt irq = GpioLock();

	if (GpioPins[pinId].iIsr != NULL)

		{

		GpioUnlock(irq);

		// already bound

		return KErrInUse;

		}

	GpioPins[pinId].iIsr = aIsr;

	GpioPins[pinId].iPtr = aPtr;

	GpioUnlock(irq);

	return KErrNone;

	}

EXPORT_C TInt GPIO::UnbindInterrupt

	(

	TInt aId

	)

	{

    TUint16 pinId = DevicePinId(aId);

	if (pinId > KHwGpioPinMax)

		{

		return KErrArgument;

		}

	TInt irq = GpioLock();

	if (GpioPins[pinId].iIsr == NULL)

		{

		GpioUnlock(irq);

		// nothing bound

		return KErrGeneral;

		}

	GpioPins[pinId].iIsr = NULL;

	GpioPins[pinId].iPtr = NULL;

	GpioUnlock(irq);

	return KErrNone;

	}

EXPORT_C TInt GPIO::EnableInterrupt

	(

	TInt aId

	)

	{

    TUint16 pinId = DevicePinId(aId);

	if (pinId > KHwGpioPinMax)

		{

		return KErrArgument;

		}

	TInt irq = GpioLock();

	if (GpioPins[pinId].iIsr == NULL)

		{

		GpioUnlock(irq);

		// nothing bound

		return KErrGeneral;

		}

	// hold value so it can be read after triggering

	TUint32 held = AsspRegister::Read32(KHwRwGpio_Int_Hold);

	AsspRegister::Write32(KHwRwGpio_Int_Hold, held | 1<<pinId);

	// enable interrupt

	AsspRegister::Write32(KHwRwGpio_Int_Enable, 1<<pinId);

	GpioUnlock(irq);

	return KErrNone;

	}

EXPORT_C TInt GPIO::DisableInterrupt

	(

	TInt aId

	)

	{

    TUint16 pinId = DevicePinId(aId);

	if (pinId > KHwGpioPinMax)

		{

		return KErrArgument;

		}

	TInt irq = GpioLock();

	if (GpioPins[pinId].iIsr == NULL)

		{

		GpioUnlock(irq);

		// nothing bound

		return KErrGeneral;

		}

	// disable interrupt

	AsspRegister::Write32(KHwWoGpio_Int_Disable, 1<<pinId);

	// disable hold

	TUint32 held = AsspRegister::Read32(KHwRwGpio_Int_Hold);

	AsspRegister::Write32(KHwRwGpio_Int_Hold, held & !(1<<pinId));

	GpioUnlock(irq);

	return KErrNone;

	}

EXPORT_C TInt GPIO::IsInterruptEnabled

	(

	TInt    aId,

   	TBool & aEnable

	)

	{

    TUint16 pinId = DevicePinId(aId);

	if (pinId > KHwGpioPinMax)

		{

		return KErrArgument;

		}

	TInt irq = GpioLock();

	if (GpioPins[pinId].iIsr == NULL)

		{

		GpioUnlock(irq);

		// nothing bound

		return KErrGeneral;

		}

	aEnable = AsspRegister::Read32(KHwRwGpio_Int_Enable) & (1<<pinId);

	GpioUnlock(irq);

	return KErrNone;

	}

EXPORT_C TInt GPIO::ClearInterrupt

	(

	TInt aId

	)

	{

    TUint16 pinId = DevicePinId(aId);

	if (pinId > KHwGpioPinMax)

		{

		return KErrArgument;

		}

	// clear pin interrupt status

	AsspRegister::Write32(KHwRwGpio_Int, 1<<pinId);

	return KErrNone;

	}

EXPORT_C TInt GPIO::GetMaskedInterruptState

	(

	TInt    aId,

   	TBool & aActive

	)

	{

    TUint16 pinId = DevicePinId(aId);

	if (pinId > KHwGpioPinMax)

		{

		return KErrArgument;

		}

	TInt irq = GpioLock();

	aActive = AsspRegister::Read32(KHwRwGpio_Int_Enable) & AsspRegister::Read32(KHwRwGpio_Int) & (1<<pinId);

	GpioUnlock(irq);

	return KErrNone;

	}

EXPORT_C TInt GPIO::GetRawInterruptState

	(

	TInt    aId,

   	TBool & aActive

	)

	{

    TUint16 pinId = DevicePinId(aId);

	if (pinId > KHwGpioPinMax)

		{

		return KErrArgument;

		}

	aActive = AsspRegister::Read32(KHwRwGpio_Int) & (1<<pinId);

	return KErrNone;

	}

EXPORT_C TInt GPIO::SetInterruptTrigger

	(

	TInt                  aId,

   	TGpioDetectionTrigger aTrigger

	)

	{

    TUint16 pinId = DevicePinId(aId);

	if (pinId > KHwGpioPinMax)

		{

		return KErrArgument;

		}

	TUint modeRegister = KHwRwGpio_Int_Mode0 + ((pinId >> 3) << 2);

	TUint modeShift = pinId & 0x7;

	TUint mode;

	switch (aTrigger)

		{

	case ELevelLow:

		mode = KHwGpioLevelLow;

		break;

	case ELevelHigh:

		mode = KHwGpioLevelHigh;

		break;

	case EEdgeFalling:

		mode = KHwGpioEdgeFalling;