/*
* 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 "cryptojobs.h"

EXPORT_C TraceFunction * &TraceFunction::HeadRef()
	{
	static TraceFunction *sHead = 0;
	return sHead;
	}



EXPORT_C DCryptoJobScheduler::DCryptoJobScheduler()
	{
	TRACE_FUNCTION("DCryptoJobScheduler");
	}

EXPORT_C DCryptoJobScheduler::~DCryptoJobScheduler()
	{
	TRACE_FUNCTION("~DCryptoJobScheduler");
	// At this point the LDD channels and PDD factory/chans should
	// have already been deleted...
	}


EXPORT_C void DCryptoJobScheduler::ScheduleJob(CryptoJob *aJob)
	{
	TRACE_FUNCTION("ScheduleJob");
	if(aJob->iInJobList)
		{
		// Already in a job list
		// If it is the current job and it is not running then try and schedule it
		// It was probably stalled waiting for the user to read and/or write data.
		if((aJob == iJobList) && (aJob->iState != CryptoJob::ERunning))
			{
			// Job is not running, and is first in list, so schedule
			// it without rescheduling the first job (which is us!)
			Schedule(EFalse);
			return;
			}
		// Attempt to reschedule current job, ie if it is not running
		// save its state and try running a different job.
		Schedule(ETrue);
		return;
		}

	// Not in list, so add it
	aJob->iJobScheduler = this;
	aJob->iNext = 0;
	if(aJob->iState == CryptoJob::ECreated)
		{
		aJob->iState = CryptoJob::EReadyForFirstRun;
		}
	if(iJobList == 0)
		{
		// Only job
		iJobList = aJob;
		aJob->iInJobList = ETrue;
		}
	else
		{
		// Insert as second on list.
		// 
		// This quick and easy to do because it does not require a
		// re-schedule or a full list walk. It is slightly unfair to
		// existing jobs, but usually there will only be the head job
		// anyway.
		CryptoJob *p = iJobList->iNext;
		iJobList->iNext = aJob;
		aJob->iNext = p;
		aJob->iInJobList = ETrue;
		}
	
	// Attempt re-schedule
	Schedule(ETrue);
	}

EXPORT_C void DCryptoJobScheduler::DeScheduleJob(CryptoJob *aJob)
	{
	TRACE_FUNCTION("DeScheduleJob");
	if((aJob->iState == CryptoJob::EReady) || (aJob->iState == CryptoJob::ERunning))
		{
		aJob->DoReleaseHw();
		}
	
	aJob->iState = CryptoJob::ECreated;
	
	// Hunt for and remove job from queue.
	// This is a linear search, BUT the list length is probably one...
	// Try and set pp to point to the pointer to the job we are removing
	CryptoJob **pp = &iJobList; 
	while(*pp != aJob && *pp)
		{
		pp = &((*pp)->iNext);
		}
	if(*pp == aJob)
		{
		*pp = (*pp)->iNext;
		aJob->iNext = 0;
		aJob->iJobScheduler = 0;
		aJob->iInJobList = EFalse;
		}
	}



EXPORT_C void DCryptoJobScheduler::SliceComplete(CryptoJob *aJob, TInt aStatus)
	{
	TRACE_FUNCTION("SliceComplete");
	// Need start next slice or swap to another job and start it
	if(aJob != iJobList)
		{
		Kern::Printf("DCryptoJobScheduler::SliceComplete - not running job 0x%x=0x%x",
					 aJob, iJobList);
		return;
		}
	
	if(aStatus != KErrNone)
		{
		JobComplete(aJob, aStatus);
		return;
		}

	Schedule(ETrue); // Change jobs and run top one
	return;
	}


EXPORT_C void DCryptoJobScheduler::JobComplete(CryptoJob *aJob, TInt aStatus)
	{
	TRACE_FUNCTION("JobComplete");
	if(aJob != iJobList)
		{
		Kern::Printf("DCryptoJobScheduler::JobComplete - not running job 0x%x=0x%x",
					 aJob, iJobList);
		return;
		}

	// Pop job and update state
	DeScheduleJob(aJob);
	
	aJob->iCallbacks->JobComplete(aStatus);

	Schedule(EFalse); // Run top job
	}

void DCryptoJobScheduler::Schedule(TBool aReschedule)
	{
	TRACE_FUNCTION("Schedule");
	if(iJobList == 0)
		{
		return;
		}

	if(iJobList->iState == CryptoJob::ERunning)
		{
		// h/w busy so can not do anything now.
		return;
		}
	
	if((iJobList->iNext == 0) && (iJobList->iState == CryptoJob::EStalled))
		{
		// Only one job in list and its stalled. Leave it on the h/w
		// as an optimisation.
		return;
		}

	if(iJobList->iNext)
		{
		// More than one job in list.
		// If top job is stalled, or reschedule is requested then swap jobs
		// Only the top job can ever be marked as EStalled.
		// (Only running job can stall and new jobs get inserted second in the list)
		TBool stalledJob = (iJobList->iState == CryptoJob::EStalled);
		if(stalledJob || aReschedule)
			{
			//
			// Pop current job from front of list
			//
			CryptoJob *oldJob = iJobList;
			iJobList = iJobList->iNext;
			oldJob->iNext = 0;
			if(oldJob->DoSaveState())
				{
				// State was saved
				oldJob->iState = CryptoJob::EReadySavedState;
				}
			else
				{
				// No state was saved
				oldJob->iState = CryptoJob::EReadyNoSavedState;
				}
			if(stalledJob)
				{
				oldJob->iInJobList = EFalse;
				}
			else
				{
				//
				// Append oldJob to end of list
				//
				// Find ptr to last job
				CryptoJob **pp = &iJobList;
				while(*pp)
					{
					pp = &(*pp)->iNext;
					}
				// Append
				*pp = oldJob;
				}
			}
		}
	
	//
	// Run new job
	//
	CryptoJob *firstJob = iJobList;

	switch(firstJob->iState)
		{
		case CryptoJob::EReady:
			firstJob->DoSlice(EFalse);
			break;

		case CryptoJob::EReadyForFirstRun:
			firstJob->iState = CryptoJob::EReady;
			firstJob->DoSlice(ETrue);
			break;

		case CryptoJob::EReadyNoSavedState:
			firstJob->iState = CryptoJob::EReady;
			firstJob->DoSlice(EFalse);
			break;

		case CryptoJob::EReadySavedState:
			firstJob->iState = CryptoJob::EReady;
			firstJob->DoRestoreState();
			firstJob->DoSlice(EFalse);
			break;
			
		case CryptoJob::ECreated:
		case CryptoJob::EStalled:
		default:
			Kern::Printf("DCryptoJobScheduler::Schedule bad state %d", iJobList->iState);
			DeScheduleJob(firstJob); // Abort/remove from list
			Schedule(EFalse);
			return;
		}

	return;
	}


EXPORT_C CryptoJob::CryptoJob()
	: iState(ECreated),
	  iJobScheduler(0),
	  iCallbacks(0),
	  iNext(0),
	  iInJobList(EFalse)
	{
	TRACE_FUNCTION("CryptoJob");
	}

EXPORT_C CryptoJob::~CryptoJob()
	{
	TRACE_FUNCTION("~CryptoJob");
	// Do not call DeScheduleJob from here because it will crash....  The
	// derived class destructor has already run and the object is now
	// considered to be of type CryptoJob (not the derived class) so
	// most virtual functions are pure virtual and calling them will
	// cause a crash.
	}

EXPORT_C void CryptoJob::Stalled()
	{
	TRACE_FUNCTION("Stalled");
	iState = EStalled;
	iJobScheduler->SliceComplete(this, KErrNone);	
	}

EXPORT_C void CryptoJob::Resume()
	{
	TRACE_FUNCTION("Resume");
	if(iState == EStalled)
		{
		iState = EReady;
		}
	iJobScheduler->ScheduleJob(this);	
	}

EXPORT_C void CryptoJob::DeScheduleJob()
	{
	TRACE_FUNCTION("DeScheduleJob");
	if(iJobScheduler)
		{
		iJobScheduler->DeScheduleJob(this);
		}
	}

EXPORT_C void CryptoJob::SetRunning(TBool aRunning)
	{
	TRACE_FUNCTION("SetRunning");
	if(aRunning)
		{
		if((iState != EReady) && (iState != ERunning))
			{
			Kern::Printf("CryptoJob::SetRunning(%d) iState is %d this=%x", aRunning, iState, this);
			Kern::Fault("CryptoJob", 42);
			}
		iState = ERunning;
		}
	else
		{
		if((iState != ERunning) && (iState != EReady))
			{
			Kern::Printf("CryptoJob::SetRunning(%d) iState is %d this=%x", aRunning, iState, this);
			Kern::Fault("CryptoJob", 43);
			}
		iState = EReady;
		}
	}

EXPORT_C CryptoJob::CryptoJobState CryptoJob::State() const
	{
	TRACE_FUNCTION("State");
	return iState;
	}


// End of file