/*

* 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

*/

#ifndef __CRYPTOJOBS__

#define __CRYPTOJOBS__

#include <e32cmn.h>

#include <e32ver.h>

#include <e32def.h>

#define TRACE_FUNCTION(funcName) do{ static TraceFunction tf( __FILE__ , funcName ); tf.Inc(); }while(0)

class TraceFunction

	{

public:

	TraceFunction(const char *aFileName, const char *aFunctionName)

		: iFileName(aFileName),

		  iFunctionName(aFunctionName),

		  iHitCount(0),

		  iNext(HeadRef())

		{

		HeadRef() = this;

		}

	void Inc()

		{

		++iHitCount;

		}

static void DumpCounts()

		{

		Kern::Printf("TraceFunction::DumpCounts\n");

		TraceFunction *p = HeadRef();

		while(p)

			{

			Kern::Printf("%d\t%s:%s\n", p->iHitCount, p->iFileName, p->iFunctionName);

			p->iHitCount = 0;

			p = p->iNext;

			}

		}

IMPORT_C static TraceFunction *&HeadRef();

private:

	const char *iFileName;

	const char *iFunctionName;

	TUint32 iHitCount;

	TraceFunction *iNext;

	};

class CryptoJob;

class MCryptoJobCallbacks;

class DCryptoJobScheduler : public DBase

	{

public:

	IMPORT_C DCryptoJobScheduler();

	IMPORT_C ~DCryptoJobScheduler();

	/**

	   ScheduleJob

	   If job is already queued, and is the current job, and is not

	   already running, attempt to schedule it and return.  Otherwise,

	   if already in the queue, just return.

	   If the job is not in the queue, then add it - If the queue is

	   empty it is added at the front and we attempt to run it,

	   otherwise we add it second in the queue for later scheduling.

	 */

	IMPORT_C void ScheduleJob(CryptoJob *aJob);

	/**

	   Abort the job synchronously

	   In the EReady state call DoReleaseHw derived function which

	   should, before returning, abort the job.

	   Changes the state to Idle.

	   Removes from the scheduler.

	   The caller is expected to complete any outstanding user request.

	*/

	IMPORT_C void DeScheduleJob(CryptoJob *aJob);

	/**

	   SliceComplete

	   Called by a job when the current slice is complete. The job

	   should update its internal state before calling us.

	   The specified job MUST be the current job.

	 */

	IMPORT_C void SliceComplete(CryptoJob *aJob, TInt aStatus);

	/**

	   JobComplete

	   Called by a job when the final slice is complete.

	   The specified job MUST be the current job.

	 */

	IMPORT_C void JobComplete(CryptoJob *aJob, TInt aStatus);

private:

	/**

	   Schedule

	   If current job is not running make it run

	 */

	void Schedule(TBool aReschedule);

	CryptoJob *iJobList;

	};

class DCryptoLddChannel;

class CryptoJob

	{

public:

	IMPORT_C CryptoJob();

	IMPORT_C virtual ~CryptoJob();

	virtual void SetDfcQ(TDfcQue *aDfcQue) = 0;

	IMPORT_C void Stalled();  // This job MUST be the current job

	IMPORT_C void Resume();

	IMPORT_C void DeScheduleJob();

	IMPORT_C void SetRunning(TBool aRunning);

	virtual void GetToPddBuffer(TUint8 * &aBuf, TUint32 &aBufLen, TBool &aMore) = 0;

	virtual void BytesWrittenToPdd(TUint32 aBytes) = 0;

	virtual void GetFromPddBuffer(TUint8 * &aBuf, TUint32 &aBufLen, TBool &aMore) = 0;

	virtual void BytesReadFromPdd(TUint32 aBytes) = 0;

	enum CryptoJobState 

	{

		ECreated, 			// Not registered with LDD factory

		EReadyForFirstRun, 	// Not running, but could run next for the first time

		ERunning,			// H/w is currently working on this job

		EReady,			  	// Is the current job (h/w is setup), but h/w is idle

		EReadyNoSavedState,	// Ready to run

		EReadySavedState,	// Ready to run, but requires state restore

		// EStalled

		//

		// Three cases:-

		//

		// 1) Already got enough data but LDD hasn't read it yet.

		// 2) No space for more h/w output

		// 3) No more data to feed to h/w

		//

		// Ultimately recoverd by the LDD reading/writing data and/or

		// deleting the job.

		EStalled

	};

 	IMPORT_C CryptoJobState State() const;

private:

	friend class DCryptoJobScheduler;

	/**

	 */

	virtual void DoSlice(TBool aFirstSlice) = 0;

	/**

	   DoSaveState

	   Save the current job h/w state so that the job can be later

	   restored when we are re-scheduled.

	   If there is state to save it should return ETrue (in which case

	   DoRestoreState will be called before our DoSlice function is

	   next called).

	   If the h/w state does not require saving/restore it should

	   return EFalse.

	*/

	virtual TBool DoSaveState() = 0;

	/**

	   DoRestoreState

	   Restore the h/w state. The caller will almost certainly call

	   DoSlice just after this to continue the job.

	*/

	virtual void DoRestoreState() = 0;

	/**

	   DoReleaseHw

	   Only called in state EReady or ERunning

	   Should abort the operation and release h/w (unhook ISRs etc)

	   before returning.

	   Later the caller will probably complete the user request...

	 */

	virtual void DoReleaseHw() = 0;

	CryptoJobState iState;

protected:

	DCryptoJobScheduler *iJobScheduler;

	MCryptoJobCallbacks *iCallbacks;

private:

	CryptoJob *iNext;

	TBool iInJobList;

	};

class MCryptoJobCallbacks

	{

public:

	/**

	   DataRequired

	   PDD is requesting more data to process.

	   Normally the LDD will write one or more bytes into the supplied

	   buffer and return the number of bytes written. It is also legal

	   for the LDD to not write any bytes and return 0.

	   If not enough bytes are supplied, the PDD will underrun and

	   stall (this function might not be re-called).

	   The LDD should provide more data to the h/w via the

	   GetToPddBuffer/BytesWrittenToPdd functions.

	   @return KErrNone or error code

	*/

	virtual TInt DataRequired() = 0;

	/**

	   DataAvailable

	   PDD has output data available for copying to the user.

	   This function will be called when the PDD is running low out

	   space for storing output data of if all input data has been

	   processed.

	   Normally the LDD would copy all the supplied data to the user.

	   It is legal for the LDD to copy less bytes, but this may cause

	   and the PDD to overrun and stall (this function might not be

	   re-called).

	   The LDD should use the GetFromPddBuffer/BytesReadFromPdd

	   functions to read data from the PDD.

	   @return KErrNone or error code

	*/

	virtual TInt DataAvailable() = 0;

	/**

	   JobComplete

	   The job scheduler has declared this job complete (maybe with an

	   error), and calls this function to tell the LDD to complete the

	   user request.

	*/

	virtual void JobComplete(TInt aResult) = 0;

	};

class CryptoJobRandom : public CryptoJob

	{

public:

	/**

	   SetDetails

	   Setup and start job. Results later available via ResultsBuffer()

	   @param Ptr to the DCryptoJobScheduler for this type of job

	   @param Ptr to the LDD object for MCryptoJobCallbacks

	   @param aNumOfBytes Total number of random numbers the user requires

	*/

	virtual void SetDetails(DCryptoJobScheduler *aJobScheduler, 

							MCryptoJobCallbacks *aCallbacks,

							TUint32 aNumOfBytes) = 0;

	};

class CryptoJobAes : public CryptoJob

	{

public:

	/**

	   GetKeyBuffer

	   Get ptr to KEY buffer to copy user data into. Max key length is

	   32 bytes (256 bits)

	   @param Pointer to key buffer

	*/

	virtual TUint8 *GetKeyBuffer() = 0;

	/**

	   GetIVBuffer

	   Get ptr to IV buffer to copy user IV data into. 16 bytes long.

	   @param Pointer to IV buffer

	*/

	virtual TUint8 *GetIVBuffer() = 0;

	/**

	   MaxBytes

	   @param Length of buffer returned by Buffer().

	*/

	virtual TUint32 MaxBytes() const = 0;

	/**

	   Buffer

	   Get ptr to PDD buffer to copy user data into and results from

	   Buffer length <= MaxBytes().

	   @param Pointer to key buffer

	*/

	virtual TUint8 *GetIOBuffer() = 0;

	/**

	   SetDetails

	   @param Ptr to the DCryptoJobScheduler for this type of job

	   @param Ptr to the LDD object for MCryptoJobCallbacks

	   @param aEncrypt True requests encryption, false decryption

	   @param aKeyLength Length of key in bytes

	   @param aMode See RCryptoDriver::TChainingMode

	   @return KErrNone or error code

	*/

	virtual TInt SetDetails(DCryptoJobScheduler *aJobScheduler, 

							MCryptoJobCallbacks *aCallbacks,

							TBool aEncrypt, 

							TInt aKeyLengthBytes,

							RCryptoDriver::TChainingMode aMode) = 0;

	virtual void NotifyReadRequestLength(TUint32 aReadRequestLength) = 0;

	virtual void HwPerfCheck() = 0;

	};

#endif