// Copyright (c) 1994-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:
// omap3530/omap3530_drivers/gpio/gpio_interrupts.cpp
//

#include <e32cmn.h>
#include <nk_priv.h>
#include <assp/omap3530_assp/omap3530_gpio.h>
#include <assp/omap3530_assp/omap3530_irqmap.h>
#include <assp/omap3530_assp/omap3530_ktrace.h>
#include <assp/omap3530_assp/omap3530_assp_priv.h>
#include <assp/omap3530_assp/locks.h>

NONSHARABLE_CLASS( TGpioDispatcher ) : public MInterruptDispatcher
	{
	public:
		TGpioDispatcher();

		TInt Init();

		virtual TInt Bind(TInt aId, TIsr aIsr, TAny* aPtr);
		virtual TInt Unbind(TInt aId);
		virtual TInt Enable(TInt aId);
		virtual TInt Disable(TInt aId);
		virtual TInt Clear(TInt aId);
		virtual TInt SetPriority(TInt aId, TInt aPriority);

	private:
		static void Spurious( TAny* aParam );
		static void DispatchIsr( TAny* aParam );

		static TInt GetGPIOPin( TInt aId,GpioPin *aPin );
		static TInt SetGPIOPin(TInt aId,GpioPin *aPin);

		static FORCE_INLINE TBool IsValidId( TInt aId );
	};

TSpinLock GPIOpinsDescLock(/*TSpinLock::EOrderGenericIrqLow0*/);
static GpioPin	GpioPins[KHwGpioPinMax];


TGpioDispatcher::TGpioDispatcher()
	{
	for (TInt32 i = 0; i < KHwGpioPinMax; i++)
		{
		GpioPins[i].iMode = GPIO::EIdle;
		GpioPins[i].irq.iIsr = Spurious;
		GpioPins[i].irq.iPtr = &GpioPins[i];	
		GpioPins[i].iBankAddr = GPIO_BASE_ADDRESS(i);
		GpioPins[i].iBank = i / KHwGpioPinsPerBank;
		GpioPins[i].iIrqVector =  EOmap3530_IRQ29_GPIO1_MPU_IRQ +GpioPins[i].iBank;
		}
	}


TInt TGpioDispatcher::Init()
	{
	for(TInt i=0; i < KHwGpioBanks; i++)
		{		
		TInt r = Interrupt::Bind(EOmap3530_IRQ29_GPIO1_MPU_IRQ+i,DispatchIsr,(TAny*) i); 
		// Pass in a pointer to the first pin in the bank - shouldn't use addition on the constant here	
		__ASSERT_ALWAYS(r==KErrNone,Kern::Fault("ExternalInterrupt::%s Cant Bind to %d",EOmap3530_IRQ29_GPIO1_MPU_IRQ+i));	
		}

	Register( EIrqRangeBaseGpio );

	return KErrNone;
	}



TInt TGpioDispatcher::GetGPIOPin(TInt aId,GpioPin *aPin)
	{
	
	if(! ( aId >= 0 && aId <  KHwGpioPinMax)  )
			return KErrArgument;
	
	TInt irq = /*NKern::DisableAllInterrupts();*/__SPIN_LOCK_IRQSAVE_R(GPIOpinsDescLock);
	memcpy(aPin,&GpioPins[aId],sizeof(GpioPin));
	/*NKern::RestoreInterrupts(irq);*/__SPIN_UNLOCK_IRQRESTORE_R(GPIOpinsDescLock,irq);	
	
	return KErrNone;	
	}

TInt TGpioDispatcher::SetGPIOPin(TInt aId,GpioPin *aPin)
	{
		
	if(! ( aId >= 0 && aId <  KHwGpioPinMax)  )
			return KErrArgument;
	
	TInt irq = /*NKern::DisableAllInterrupts();*/__SPIN_LOCK_IRQSAVE_W(GPIOpinsDescLock);				
	memcpy(&GpioPins[aId],aPin,sizeof(GpioPin ));
	/*NKern::RestoreInterrupts(irq);*/__SPIN_UNLOCK_IRQRESTORE_W(GPIOpinsDescLock,irq);
	
	return KErrNone;
	}

FORCE_INLINE TBool TGpioDispatcher::IsValidId( TInt aId )
	{
	return ((TUint)aId < EGPIOIRQ_END && (TUint)aId>=EGPIOIRQ_FIRST);
	}


void TGpioDispatcher::Spurious(TAny* aId)
	{
	Kern::Fault("SpuriousExtInt",(TInt)aId);
	}


void TGpioDispatcher::DispatchIsr(TAny *aPtr)
	{
	Interrupt::Disable(EOmap3530_IRQ29_GPIO1_MPU_IRQ + (TInt) aPtr);
	
	//need to spinlock the gpio here.....
	TUint32	highVectors = AsspRegister::Read32(KGPIO_BASE_ADDRESSES[(TInt) aPtr] + KGPIO_IRQSTATUS1);
  	AsspRegister::Write32(KGPIO_BASE_ADDRESSES[(TInt) aPtr] + KGPIO_IRQSTATUS1, highVectors);
	
	GpioPin pin;
	for (TInt i =  0; i < KHwGpioPinsPerBank ; i++,highVectors >>=1)
		{
		if(highVectors & 0x1)
			{		
			GetGPIOPin(i+(TInt)aPtr*KHwGpioPinsPerBank, &pin);
			(*pin.irq.iIsr)(pin.irq.iPtr); // dispatch this pin's ISR
			}
		}
	Interrupt::Enable(EOmap3530_IRQ29_GPIO1_MPU_IRQ + (TInt)aPtr);
	}


TInt TGpioDispatcher::Bind(TInt anId, TIsr anIsr, TAny* aPtr)
	{
	if(IsValidId(anId))
		{
		//we want to bind the callers isrfunc to the pin dispatch here
		GpioPin pin;
		GetGPIOPin(anId- EGPIOIRQ_FIRST,&pin);
		pin.irq.iIsr = anIsr;
		pin.irq.iPtr = aPtr;
		SetGPIOPin(anId- EGPIOIRQ_FIRST,&pin);
		return KErrNone;
		} 
	else
		{
		return KErrArgument;
		}
	}

TInt TGpioDispatcher::Unbind(TInt anId)
	{
	__KTRACE_OPT(KGPIO,Kern::Printf("GPIO:%s id=%d",__FUNCTION__,anId));

	if(IsValidId(anId))
		{
		GpioPin pin;
		TInt pinNr = anId - EGPIOIRQ_FIRST;
		GetGPIOPin(pinNr,&pin);
		pin.irq.iIsr=Spurious;
		pin.irq.iPtr=NULL;
		SetGPIOPin(pinNr,&pin);
		return KErrNone;
		}
	else
		{
		return KErrArgument;
		}
	}
	

TInt TGpioDispatcher::Enable(TInt anId)
	{
	__KTRACE_OPT(KGPIO,Kern::Printf("GPIO:%s id=%d +",__FUNCTION__,anId));
	CHECK_PRECONDITIONS(MASK_NO_FAST_MUTEX,"GPIO::InterruptEnable Cant Hold Mutex in Blocking function");			
	
	if(IsValidId(anId))
		{
		GpioPin pin;
		TInt pinNr = anId - EGPIOIRQ_FIRST;	
		GetGPIOPin(pinNr,&pin);
		
		if(Spurious == pin.irq.iIsr)
			{
			
			__KTRACE_OPT(KGPIO,Kern::Printf("GPIO:%s id=%d NOT BOUND",__FUNCTION__,anId));
			return KErrNotReady;
			}
		AsspRegister::Write32(pin.iBankAddr+KGPIO_SETIRQENABLE1,GPIO_PIN_OFFSET( pinNr));
		
		if(!Omap3530Interrupt::IsInterruptEnabled(pin.iIrqVector))
			Interrupt::Enable(pin.iIrqVector);
		
		return KErrNone;
		}
	else
		{
		return KErrArgument; 
		}
	}

TInt TGpioDispatcher::Disable(TInt anId)
	{
	
	__KTRACE_OPT(KGPIO,Kern::Printf("GPIO:%s id=%d",__FUNCTION__,anId));
	CHECK_PRECONDITIONS(MASK_NO_FAST_MUTEX,"GPIO::InterruptDisable Cant Hold Mutex in Blocking function");
	if(IsValidId(anId))
		{		
		TInt pinNr = anId- EGPIOIRQ_FIRST;
		GpioPin pin;
		GetGPIOPin(pinNr, &pin);
		
		AsspRegister::Write32(pin.iBankAddr+KGPIO_CLEARIRQENABLE1, GPIO_PIN_OFFSET(pinNr));
		
		//is this the last one for this bank ? then unmap
		if(0x00 == AsspRegister::Read32(pin.iBankAddr+KGPIO_IRQENABLE1))
			{
			Interrupt::Disable(pin.iIrqVector);
			}
		return KErrNone;
		}
	else
		{
		return KErrArgument; 
		}
	}

TInt TGpioDispatcher::Clear(TInt anId)
	{
	
	__KTRACE_OPT(KGPIO,Kern::Printf("GPIO:%s id=%d",__FUNCTION__,anId));
	CHECK_PRECONDITIONS(MASK_NO_FAST_MUTEX,"GPIO::InterruptDisable Cant Hold Mutex in Blocking function");
		
	if(IsValidId(anId))
		{
		TInt pinNr = anId- EGPIOIRQ_FIRST;
		GpioPin myPin;
		GetGPIOPin(pinNr, &myPin);
		
		AsspRegister::Write32((myPin.iBankAddr+KGPIO_IRQSTATUS1),  GPIO_PIN_OFFSET(pinNr));
		//if that was the only high bit clear the mainline as well
		if(0 == AsspRegister::Read32(myPin.iBankAddr+KGPIO_IRQSTATUS1))
			{
			Interrupt::Clear(myPin.iIrqVector);
			}
		}
	return KErrNone;
	}

TInt TGpioDispatcher::SetPriority(TInt aId, TInt aPriority)
	{
	return KErrNotSupported;
	}


GLDEF_C TInt InitGpioInterrupts()
	{
	TInt r = KErrNoMemory;

	TGpioDispatcher* dispatcher = new TGpioDispatcher;
	if( dispatcher )
		{
		r = dispatcher->Init();
		}
	return r;
	}