/*

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

 *

 */

 #include <kernel/kern_priv.h>

 #include <template_assp.h>

 #include <drivers/gpio.h>

 const TInt32		KHwGpioPinMax		= 0;	// TO DO: max pin number this GPIO chip supports

 const TInt32		KIntIdGpio		= 0;	// TO DO: need to define which interrupt the GPIO chip is attached to

 //

 // TO DO: if the GPIO chip doesn't support specific features

 // such as debouncing or pin modes, then it may be

 // necessary to store them ourselves in an array of GpioPins

 // other features such as pin bias or idle configurations

 // may be left as KErrNotSupported

 //

 class GpioPin

 	{

 public:

    	TGpioIsr		iIsr;	// e.g. we may want to remeber the isr attached to a pin

 	TAny *			iPtr;	// argument to pass to isr

 	};

 static GpioPin	GpioPins[KHwGpioPinMax+1];

 static TInt32	GpioInterruptId; // place to store interrupt handle returned from Interrupt::Bind()

 /**

 GPIO interrupt handler

 generic argument (TAny*) is a pointer to the GpioPins array

 */

 void GpioIsrDispatch(TAny *aPtr)

 	{

 	// TO DO: work out which pins have interrupts pending

 	// and dispatch the appropriate ISR

 	GpioPin	*pins = (GpioPin *)aPtr;

 	TUint32 interrupt = 0xff; // TO DO: read gpio pending interupts

 	TUint32 enabled = 0x00; // TO DO: read gpio enabled interupts

 	TUint32	masked = interrupt & enabled; // TO DO: read masked interrupts

 	// check each pin and dispatch ISR if necessary

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

 		{

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

 			{

 			// we have a pending interrupt and a registered ISR

 			(*pins[i].iIsr)(pins[i].iPtr); // dispatch this pin's ISR

 			}

 		masked >>= 1;

 		}

 	Interrupt::Clear(GpioInterruptId);

 	}

 EXPORT_C TInt GPIO::SetPinMode

 	(

 	TInt      aId,

    	TGpioMode aMode

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: store pin mode and return

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::GetPinMode

 	(

 	TInt        aId,

    	TGpioMode & aMode

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: set aMode = pin mode

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::SetPinDirection

 	(

 	TInt           aId,

    	TGpioDirection aDirection

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax || aDirection == ETriStated)

 		{

 		return KErrArgument;

 		}

 	// TO DO: if we support setting the pin direction then do it here

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::GetPinDirection

 	(

 	TInt             aId,

    	TGpioDirection & aDirection

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: if we support getting the pin direction then do it here

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::SetPinBias

 	(

 	TInt      aId,

    	TGpioBias aBias

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: if we support setting the pin bias then do it here

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::GetPinBias

 	(

 	TInt        aId,

    	TGpioBias & aBias

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: if we support getting the pin bias then do it here

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::SetPinIdleConfigurationAndState

 	(

 	TInt        aId,

    	TInt		/*aConf*/

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: if we support setting the pin idle config then do it here

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::GetPinIdleConfigurationAndState

 	(

 	TInt        aId,

    	TInt	  & aBias

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: if we support getting the pin idle config then do it here

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::BindInterrupt

 	(

 	TInt     aId,

    	TGpioIsr aIsr,

    	TAny *   aPtr

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax || aIsr == NULL)

 		{

 		return KErrArgument;

 		}

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

 		{

 		// already bound

 		return KErrInUse;

 		}

 	// record isr and arg bound to this pin

 	GpioPins[aId].iIsr = aIsr;

 	GpioPins[aId].iPtr = aPtr;

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::UnbindInterrupt

 	(

 	TInt aId

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

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

 		{

 		// nothing bound

 		return KErrGeneral;

 		}

 	// NULL isr bound to this pin

 	GpioPins[aId].iIsr = NULL;

 	GpioPins[aId].iPtr = NULL;

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::EnableInterrupt

 	(

 	TInt aId

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

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

 		{

 		// nothing bound

 		return KErrGeneral;

 		}

 	// TODO: enable interrupts on this pin

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::DisableInterrupt

 	(

 	TInt aId

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

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

 		{

 		// nothing bound

 		return KErrGeneral;

 		}

 	// TODO: disable interrupts on this pin

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::IsInterruptEnabled

 	(

 	TInt    aId,

    	TBool & aEnable

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

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

 		{

 		// nothing bound

 		return KErrGeneral;

 		}

 	// TO DO: are interrupts enabled on this pin ?

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::ClearInterrupt

 	(

 	TInt aId

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

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

 		{

 		// nothing bound

 		return KErrGeneral;

 		}

 	// TO DO: clear pin interrupt status

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::GetMaskedInterruptState

 	(

 	TInt    aId,

    	TBool & aActive

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: set aActive to masked interrupt state

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::GetRawInterruptState

 	(

 	TInt    aId,

    	TBool & aActive

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: set aActive to raw (unmasked) interrupt state

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::SetInterruptTrigger

 	(

 	TInt                  aId,

    	TGpioDetectionTrigger aTrigger

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: set interrupt trigger on this pin

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::EnableWakeup

 	(

 	TInt aId

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: enable wakeup on this pin

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::DisableWakeup

 	(

 	TInt aId

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: disable wakeup on this pin

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::IsWakeupEnabled

 	(

 	TInt    aId,

    	TBool & aEnable

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: set aEnable wakeup state for this pin

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::SetWakeupTrigger

 	(

 	TInt                  aId,

    	TGpioDetectionTrigger aTrigger

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: set wakeup trigger on this pin

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::SetDebounceTime

 	(

 	TInt aId,

    	TInt aTime

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: set debounce time for this pin

 	// it may be necessary to emulate debouncing ourselves

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::GetDebounceTime

 	(

 	TInt   aId,

    	TInt & aTime

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: get debounce time for this pin

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::GetInputState

 	(

 	TInt         aId,

    	TGpioState & aState

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: read the input state of this pin

 	// if debouncing is handled by the driver here

 	// is where we will need to work out what the

 	// debounced state is

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::SetOutputState

 	(

 	TInt       aId,

    	TGpioState aState

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: set the output state of this pin

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::GetOutputState

 	(

 	TInt         aId,

    	TGpioState & aState

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: get the output state of this pin

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::GetInputState

 	(

 	TInt                  aId,

    	TGpioCallback		* aCb

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: get the input state of this pin

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::SetOutputState

 	(

 	TInt                  aId,

 	TGpioState			  aState,

    	TGpioCallback		* aCb

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: set the ouput state of this pin

 	return KErrNone;

 	}

 EXPORT_C TInt GPIO::StaticExtension

 	(

 	TInt	  aId,

 	TInt	  aCmd,

 	TAny	* aArg1,

 	TAny	* aArg2

 	)

 	{

 	if (aId < 0 || aId > KHwGpioPinMax)

 		{

 		return KErrArgument;

 		}

 	// TO DO: call the appropriate static extension if supported

 	return KErrNotSupported;

 	}

 //

 // entry point for GPIO setup

 //

 DECLARE_STANDARD_EXTENSION()

 	{

 	// initialise GPIO pins array (if necessary)

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

 		{

 		GpioPins[i].iIsr = NULL;

 		GpioPins[i].iPtr = NULL;

 		}

 	// bind and enable GPIO Isr

 	// NB Interrupt::Bind() now returns a handle (-ve value means an error)

 	TInt r = Interrupt::Bind(KIntIdGpio, GpioIsrDispatch, &GpioPins[0]);

 	if (r < 0)

 		{

 		return r;

 		}

 	// store handle

 	GpioInterruptId = r;

 	// NB Interrupt::Enable() now expects the handle return from Bind

 	r = Interrupt::Enable(r);

 	return r;

 	}