/*

 * 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