/*
* 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 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: 
*
*/


/**
 @file
 @internalComponent
 @released
*/
#include <kernel/kern_priv.h>
#include "cryptodriver.h"
#ifdef __MARM__
#include <omap_hrp/assp/shared/omap_reg.h>
#include <omap_hrp/assp/shared/omap_interrupt.h>
#endif
//#include "cryptoh4.h"
#include "cryptoldd.h"
#include "cryptoh4rng.h"

inline void CryptoH4JobRandom::EnableIsr()
	{
	TRACE_FUNCTION("EnableIsr");
	//	Kern::Printf("EI");
	SetRunning(ETrue);
#ifdef __MARM__
	// Enable RNG interrupt. This interrupt will then queue the
	// "random number ready" DFC
	TInt32 tmp = TOmap::Register32(KHwBaseRngReg + KHoRng_Mask);
	tmp |= 4;
	TOmap::SetRegister32(KHwBaseRngReg + KHoRng_Mask, tmp);
#else
	// Not on real h/w so just queue the DFC...
	// Queue the "random number ready" DFC
	iRandomDfc.Enque(); // Queue from task level
#endif
	}

inline void CryptoH4JobRandom::DisableIsr()
	{
	TRACE_FUNCTION("DisableIsr");
	//	Kern::Printf("DI");
#ifdef __MARM__
	TInt32 tmp = TOmap::Register32(KHwBaseRngReg + KHoRng_Mask);
	tmp &= ~4;
	TOmap::SetRegister32(KHwBaseRngReg + KHoRng_Mask, tmp);
#endif
	}



CryptoH4JobRandom::CryptoH4JobRandom(DLddChanRandom &aLddChanRandom)
	: iLddChanRandom(aLddChanRandom),
	  iJobSizeInBytes(0),
	  iSwReadByteOffset(0),
	  iHw32Index(0),
	  iIsrHooked(EFalse),
	  iRandomDfc(RandomDfc, this, 1) // DFC is priority '1'
	{
	TRACE_FUNCTION("CryptoH4JobRandom");
	//	Kern::Printf("CryptoH4JobRandom::CryptoH4JobRandom %x", this);
	}

CryptoH4JobRandom::~CryptoH4JobRandom()
	{
	TRACE_FUNCTION("~CryptoH4JobRandom");
	//	Kern::Printf("CryptoH4JobRandom::~CryptoH4JobRandom %x", this);
	UnHookIsr();
	}


void CryptoH4JobRandom::SetDfcQ(TDfcQue *aDfcQue)
	{
	TRACE_FUNCTION("SetDfcQ");
	iRandomDfc.SetDfcQ(aDfcQue);
	}

void CryptoH4JobRandom::SetDetails(DCryptoJobScheduler *aJobScheduler, 
								   MCryptoJobCallbacks *aCallbacks,
								   TUint32 aNumOfBytes)
	{
	TRACE_FUNCTION("SetDetails");
	//	Kern::Printf("CryptoH4JobRandom::SetDetails");
	iJobScheduler = aJobScheduler;
	iCallbacks = aCallbacks;
	iJobSizeInBytes = aNumOfBytes;
	}

void CryptoH4JobRandom::GetToPddBuffer(TUint8 * &aBuf, TUint32 &aBufLen, TBool &aMore)
	{
	TRACE_FUNCTION("GetToPddBuffer");
	aBuf = 0;
	aBufLen = 0;
	aMore = EFalse;
	}

void CryptoH4JobRandom::BytesWrittenToPdd(TUint32)
	{
	TRACE_FUNCTION("BytesWrittenToPdd");
	}

void CryptoH4JobRandom::GetFromPddBuffer(TUint8 * &aBuf, TUint32 &aBufLen, TBool &aMore)
	{
	TRACE_FUNCTION("GetFromPddBuffer");
	
	TInt hw8Index = iHw32Index * 4;
	TUint8 *p = (TUint8 *) iRandomBuffer;
	aBuf = &p[iSwReadByteOffset];

	TInt len = hw8Index - iSwReadByteOffset;
	if(len >= 0)
		{
		aBufLen = len;
		aMore = EFalse;
		}
	else
		{
		// Wrap round condition, but can only return contiguous bytes
		aBufLen = sizeof(iRandomBuffer) - iSwReadByteOffset;
		aMore = ETrue;
		return;
		}
	}

void CryptoH4JobRandom::BytesReadFromPdd(TUint32 aBytes)
	{
	TRACE_FUNCTION("BytesReadFromPdd");
	iSwReadByteOffset += aBytes;
	if(iSwReadByteOffset >= sizeof(iRandomBuffer))
		{
		iSwReadByteOffset -= sizeof(iRandomBuffer);
		}
	iJobSizeInBytes -= aBytes;
	}



void CryptoH4JobRandom::DoSlice(TBool aFirstSlice)
	{
	TRACE_FUNCTION("DoSlice");
	//	Kern::Printf("DoSlice(%d)", aFirstSlice);
	if(aFirstSlice)
		{
		HookIsr();
		}
	
	// Enable RNG interrupt. The interrupt will then queue the
	// "random number ready" DFC when the h/w is ready.
	// (when not on h/w, this immediately queues a DFC)
	EnableIsr();
	}

TBool CryptoH4JobRandom::DoSaveState()
	{
	TRACE_FUNCTION("DoSaveState");
	UnHookIsr();
	return ETrue; // We want DoRestoreState to be called
	}

void CryptoH4JobRandom::DoRestoreState()
	{
	TRACE_FUNCTION("DoRestoreState");
	HookIsr();
	}

void CryptoH4JobRandom::DoReleaseHw()
	{
	TRACE_FUNCTION("DoReleaseHw");
	// Disable RNG interrupt
	DisableIsr();

	// Disable/unhook ISR
	UnHookIsr();

	// Cancel DFC
	iRandomDfc.Cancel();
	
	}

TInt CryptoH4JobRandom::BytesAvailable() const
	{
	TRACE_FUNCTION("BytesAvailable");
	TInt hw8Index = iHw32Index * 4;
	TInt available = hw8Index - iSwReadByteOffset;
	if(available < 0)
		{
		available += sizeof(iRandomBuffer);
		}
	return available;	
	}

void CryptoH4JobRandom::RegionsAvailable(TUint8 * &aPtr1, TInt &aLen1, 
										 TUint8 * &aPtr2, TInt &aLen2) const
	{
	TRACE_FUNCTION("RegionsAvailable");
	TInt hw8Index = iHw32Index * 4;
	TUint8 *p = (TUint8 *) iRandomBuffer;
	aPtr1 = &p[iSwReadByteOffset];

	TInt len = hw8Index - iSwReadByteOffset;
	if(len < 0)
		{
		// Available data crosses buffer end so return two regions
		aLen1 = sizeof(iRandomBuffer) - iSwReadByteOffset;
		aPtr2 = &p[0];
		aLen2 = hw8Index;
		}
	else
		{
		// Available buffer is contiguous
		aLen1 = len;
		aPtr2 = 0;
		aLen2 = 0;
		}
	}



void CryptoH4JobRandom::HookIsr()
	{
	TRACE_FUNCTION("HookIsr");
	//	Kern::Printf("CryptoH4JobRandom::HookIsr iIsrHooked=%d this=%x", iIsrHooked, this);
#ifdef __MARM__
	if(!iIsrHooked)
		{
		TInt r = Interrupt::Bind(EIrqRng, Isr, this);
		if(r != KErrNone) Kern::Fault("CryptoH4JobRandom::HookIsr Bind failed", r);
		r = Interrupt::Enable(EIrqRng);
		if(r != KErrNone) Kern::Fault("CryptoH4JobRandom::HookIsr Enable failed", r);
		iIsrHooked = ETrue;
		}
#endif
	}

void CryptoH4JobRandom::UnHookIsr()
	{
	TRACE_FUNCTION("UnHookIsr");
	//	Kern::Printf("CryptoH4JobRandom::UnHookIsr iIsrHooked=%d this=%x", iIsrHooked, this);
#ifdef __MARM__
	if(iIsrHooked)
		{
		Interrupt::Disable(EIrqRng);
		Interrupt::Unbind(EIrqRng);
		iIsrHooked = EFalse;
		}
#endif
	}



#ifdef __MARM__
void CryptoH4JobRandom::Isr(TAny *aPtr)
	{
	TRACE_FUNCTION("Isr");
	CryptoH4JobRandom *p = static_cast<CryptoH4JobRandom *>(aPtr);
	// Disable RNG interrupt so DFC can run.
	p->DisableIsr();
	// Queue DFC to read the RNG
	p->iRandomDfc.Add();
	}
#endif

/**
  Called when the current h/w opperation is complete
*/
void CryptoH4JobRandom::RandomDfc(TAny* aPtr)
    {
    ((CryptoH4JobRandom*)aPtr)->DoRandomDfc();
    }

void CryptoH4JobRandom::DoRandomDfc()
	{
	TRACE_FUNCTION("DoRandomDfc");
	// Set state to not using hw, if we continue using the h/w we will
	// call EnableIsr which will change the state back to ERunning.
	SetRunning(EFalse);
	//	Kern::Printf("DoRandomDfc");
#ifdef __MARM__
	// Read h/w
	iRandomBuffer[iHw32Index] = TOmap::Register32(KHwBaseRngReg + KHoRng_Out);
#else
	static TUint32 n = 0;
	iRandomBuffer[iHw32Index]= n++;
#endif

	++iHw32Index;
	if(iHw32Index >= sizeof(iRandomBuffer)/sizeof(iRandomBuffer[0]))
		{
		iHw32Index = 0;
		}

	TInt outputAvailable = BytesAvailable();
	TInt space = sizeof(iRandomBuffer) - outputAvailable - 4;
	if((outputAvailable >= iJobSizeInBytes) || (space <= 0))
		{
		// Either have enough data to finish job, or out of buffer
		// space to read more.  We pass available data to the LDD, and
		// declare the slice/job done and return.

		//
		// Pass available data to LDD
		//
		// LDD will call GetFromPddBuffer/BytesReadFromPdd to read the data.
		iLddChanRandom.DataAvailable();
		}
	
	// Are we done yet?
	if(iJobSizeInBytes <= 0)
		{
		// Tell the scheduler that this slice is done
		iJobScheduler->JobComplete(this, KErrNone);
		return;
		}

	// Re-calculate output available and space
	outputAvailable = BytesAvailable();
	space = sizeof(iRandomBuffer) - outputAvailable - 4;

	if((space != 0) && (iJobSizeInBytes-outputAvailable > 0))
		{
		// We have some space and we need more data
		
		// Enable RNG interrupt. The interrupt will then queue the
		// "random number ready" DFC when the h/w is ready.
		// (when not on h/w, this immediately queues a DFC)
		EnableIsr();
		}
	else
		{
		// Job stalled - either out of space or already have enough
		// data but LDD has not take it
		Stalled();
		}
		
	return;
	}

	


// End of file