// Copyright (c) 2005-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:

// A helper test driver for testing Kernel Performance Logger implementation.

// 

//

/**

 @file

*/

#include "d_perflogger_ldd.h"

#include <kernperflogger.h>

_LIT(KDFCThreadName,"D_PL_DFC_THREAD");

const TInt KDFCThreadPriority=27;

//-----------------------------------------------------------------------------------

DKPLoggerTestHelperLDD* DKPLoggerTestHelperLDD::pSelf = NULL;	//-- static pointer to the single instance of the logical channel class

//-----------------------------------------------------------------------------------

DLogTicker::DLogTicker() : iTimer(LogTimerCallback,this)  //-- initialize log events generator

	{

    iLogDFC = NULL;

    iRequest = NULL;

    iUserThreadContext = NULL;

	}

DLogTicker::~DLogTicker()

	{

    Cancel(); //-- cancel user request, DFC, timers etc.

	Kern::DestroyClientRequest(iRequest);

    delete  iLogDFC;

	}

//-----------------------------------------------------------------------------------

/**

	Construct ticker object. Creates appropriate TDfc object for dealing with IDFC or DFC

	@param  apUserThreadContext pointer to the user thread context where the request will be completed in

	@param  apDfcQ              pointer to the DFC queue this object will be using.

	@param  aLogContext         specfies the context (ISR, DFC or IDFC) the logging will be made from. Can be NKern::EIDFC, NKern::EThread, NKern::EInterrupt

*/

void DLogTicker::Construct(DThread* aUserThreadContext, TDfcQue* aDfcQ, NKern::TContext aLogContext)

	{

    __NK_ASSERT_DEBUG(aUserThreadContext && aDfcQ);

    iLogContext = aLogContext;

    if(aLogContext == NKern::EIDFC)

		{//-- we will deal with IDFC, create appropriate DFC object

        iLogDFC = new TDfc(LogDFC, this);

		}

    else

		{

		if(aLogContext == NKern::EThread || aLogContext == NKern::EInterrupt)

			{//-- we will deal with DFC or ISR

			iLogDFC = new TDfc(LogDFC, this, aDfcQ, 0);

			}

		else

			{//-- wrong value

			__PRINT("#KPLogTest:DLogTicker::Construct() wrong context request !");

			__NK_ASSERT_DEBUG(0);

			}

		}

	__NK_ASSERT_ALWAYS(iLogDFC);

	TInt r = Kern::CreateClientRequest(iRequest);

	__NK_ASSERT_ALWAYS(r == KErrNone);

	iUserThreadContext = aUserThreadContext; //-- store user thread context co complete requests correctly

//	iLogDFC->SetDfcQ(aDfcQ); //-- attach to the given DFC queue. !!!!DON'T DO THIS FOR IDFC!!!!!

	}

//-----------------------------------------------------------------------------------

/**

	Start the state machine by scheduling a DFC (or IDFC)

	@param  apLogControl    log parameters structure

	@param  apRqStat        pointer to the user request staus object that will be completed when all loggings done.

*/

void DLogTicker::Start(const TTestLogCtrl* aLogControl, TRequestStatus* aRqStat)

	{

    __NK_ASSERT_DEBUG(aLogControl && aRqStat && iLogDFC);

    kumemget32(&iLogControl, aLogControl, sizeof(TTestLogCtrl)); //-- copy control structure from the user side

	__NK_ASSERT_DEBUG(iLogControl.iLogsNum>=0);

	__PRINT1("#KPLogTest:DLogTicker::Start() for %d loggings",iLogControl.iLogsNum);

	if (iRequest->SetStatus(aRqStat) != KErrNone)

		{//-- current request is pending, panic client thread

        __PRINT("#KPLogTest:DLogTicker::Start() request is already pending !");

        Kern::PanicCurrentThread(KPLoggerHelperTestDrv, EReqAlreadyPending);

		}

    if(iLogContext == NKern::EIDFC)

		{//-- DLogTicker::LogDFC() will be called as IDFC 

        NKern::Lock();   

        iLogDFC->Add();  //-- start

        NKern::Unlock();

		}

    else

		{//-- DLogTicker::LogDFC() will be called as DFC 

        iLogDFC->Enque(); //-- start

		}

	}

//-----------------------------------------------------------------------------------

/**

	Complete the user request when all logging done.

	This can be called from 2 concurrent places - DFC & NTimer callback, either of them can complete the request

	@param aCompletionCode request completion code

*/

void DLogTicker::CompleteRequest(TInt aCompletionCode/*=KErrNone*/)

	{

	Kern::QueueRequestComplete(iUserThreadContext, iRequest, aCompletionCode);

	}

//-----------------------------------------------------------------------------------

/**

	Cancel everything

*/

void DLogTicker::Cancel(void)

	{

    CompleteRequest(KErrCancel); //-- cancel user request

	iLogControl.iLogsNum = 0;	 // Prevent DFC from restarting the timer

	iTimer.Cancel();    //-- cancel Timer

	iLogDFC->Cancel(); //-- cancel DFC

	}

//-----------------------------------------------------------------------------------

/**

	Ticker timer callback. Can be called in ISR or DFC context.

	If called in ISR context, makes logging, and schedules a DFC to complete the request if needed.

	If called in DFC context, makes logging for DFC (not for IDFC) mode and completes the request if needed.

	@param  apSelf pointer to the DLogTicker object

*/

void DLogTicker::LogTimerCallback(TAny* aSelf)

	{

    DLogTicker *pSelf = (DLogTicker*)aSelf;

    __NK_ASSERT_DEBUG(pSelf);

    TTestLogCtrl& logClontrol = pSelf->iLogControl;

    __NK_ASSERT_DEBUG(logClontrol.iLogsNum >=0);

    TInt context = NKern::CurrentContext();

    if(context == NKern::EInterrupt)

		{//-- This callback is from ISR

        //-- make logging from ISR context, category field is ignored, it will be FastTrace::EKernPerfLog

        PERF_LOG(logClontrol.iSubCategory, logClontrol.iUserData, logClontrol.iUserData2);

        //-- kick DFC, it will probaly complete the request. 

        pSelf->iLogDFC->Add();  

		}

    else

		{//-- this is a DFC callback, but the DFC object could also have been ceated as IDFC

		//-- complete user request here if necessarily.

        if(pSelf->iLogDFC->IsIDFC())

			{//-- the logging will be made in IDFC function.

            if(pSelf->iLogControl.iLogsNum == 0)

				{//-- all done, complete the request here, because we can't do in in IDFC

                pSelf->CompleteRequest();

				}

            else

				{//-- this callback came from IDFC object, kick IDFC in a special way.

                NKern::Lock();

                pSelf->iLogDFC->Add(); 

                NKern::Unlock();

				}

			}

        else

			{//-- this callback came from IDFC object, make logging from DFC context

            //-- category field is ignored, it will be FastTrace::EKernPerfLog

            PERF_LOG(logClontrol.iSubCategory, logClontrol.iUserData, logClontrol.iUserData2);    

            pSelf->iLogDFC->Enque(); //-- kick DFC 

			}

		}

	}

//-----------------------------------------------------------------------------------

/**

	Ticker DFC or IDFC function. Kicks the timer; 

	If is called as IDFC, makes logging in this context and schedules a timer callback in DFC context to complete the request.

	If is called as DFC, schedules timer callback in DFC or ISR context. 

	@param  apSelf pointer to the DLogTicker object

*/

void DLogTicker::LogDFC(TAny* aSelf)

	{

    DLogTicker *pSelf = (DLogTicker*)aSelf;

    __NK_ASSERT_DEBUG(pSelf);

    TInt context = NKern::CurrentContext();

    (void)context; //-- avoid warning in release mode

    if(pSelf->iLogControl.iLogsNum <= 0)

		{//-- complete user request, all done. The request can also be completed in LogTimerCallback()

		//-- in case if this is a IDFC and callback is a DFC

        pSelf->CompleteRequest();    

		}

    else

		{

        TTestLogCtrl& logClontrol = pSelf->iLogControl;

        logClontrol.iLogsNum--; //-- decrease remaining number of loggings

        if(pSelf->iLogDFC->IsIDFC())

			{//-- we are in IDFC context, make logging from here, timer callback won't be IDFC

            __NK_ASSERT_DEBUG(context == NKern::EIDFC);

            //-- category field is ignored, it will be FastTrace::EKernPerfLog

            PERF_LOG(logClontrol.iSubCategory, logClontrol.iUserData, logClontrol.iUserData2);

            //-- kick the timer to have a callback in a specified time in DFC context

            //-- timer's DFC will complete the request if necessarily.

            pSelf->iTimer.OneShot(logClontrol.iLogPeriodTick, ETrue); 

			}

        else

			{//-- we are in DFC context, kick the timer to have a callback in a specified time in ISR or DFC context

            pSelf->iTimer.OneShot(logClontrol.iLogPeriodTick, !(pSelf->iLogContext == NKern::EInterrupt));

			}

		}

	}

//-----------------------------------------------------------------------------------

//###################################################################################

//#            DKPLoggerTestHelperLDD   class implementation

//###################################################################################

DKPLoggerTestHelperLDD::DKPLoggerTestHelperLDD()

	{

    //-- store the pointer to the current thread for request completion from ISR->DFC

    iClientThread = &Kern::CurrentThread();

    __NK_ASSERT_DEBUG(iClientThread);

	//-- Open client's user thread, incrementing ref. counter 

	TInt nRes = iClientThread->Open();

	__NK_ASSERT_DEBUG(nRes == KErrNone);

	(void)nRes;//-- avoid warning in release mode

    //-- initialize DFC machinery

    //iDfcQ = Kern::DfcQue0();   //-- attach to the low priority DFC queue

	if (!iDfcQ)

 		{

 		TInt r = Kern::DynamicDfcQCreate(iDfcQ, KDFCThreadPriority, KDFCThreadName);

		if (r!= KErrNone)

			{

			return;

			}

#ifdef CPU_AFFINITY_ANY

		NKern::ThreadSetCpuAffinity((NThread*)(iDfcQ->iThread), KCpuAffinityAny);			

#endif

 		}	

    iIsrLogTicker.Construct (iClientThread, iDfcQ, NKern::EInterrupt);//-- construct ISR log ticker

    iDfcLogTicker.Construct (iClientThread, iDfcQ, NKern::EThread);   //-- construct DFC log ticker

    iIDfcLogTicker.Construct(iClientThread, iDfcQ, NKern::EIDFC);     //-- construct IDFC log ticker

	}

//-----------------------------------------------------------------------------------

DKPLoggerTestHelperLDD::~DKPLoggerTestHelperLDD()

	{

    __PRINT("#KPLogTest:~DKPLoggerTestHelperLDD()");

	iClientThread->Close(NULL);

	if (iDfcQ)

		iDfcQ->Destroy();

	pSelf = NULL;  //-- clear the pointer to this class instance

	}

//-----------------------------------------------------------------------------------

/**

	static factory function for the LDD.

	@return pointer to the created (or existing) instance of the class

*/

DKPLoggerTestHelperLDD* DKPLoggerTestHelperLDD::CreateInstance()

	{

    __PRINT("#KPLogTest:DKPLoggerTestHelperLDD::CreateInstance()");

    //-- create LDD channel instance

    if(pSelf)

	    {//-- this is a singleton, can't have more than one instance

        __PRINT("#DKPLoggerTestHelperLDD::CreateInstance(): Attempt to create a second instance of a singleton!");

        return pSelf;

		}

	pSelf = new DKPLoggerTestHelperLDD;

    if(!pSelf)

		{//-- OOM 

        __PRINT("#KPLogTest:DKPLoggerTestHelperLDD::CreateInstance(): Unable to create class instance !");

		}

    return pSelf;

	}

//-----------------------------------------------------------------------------------

/**

	LDD second stage constructor

*/

TInt DKPLoggerTestHelperLDD::DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer)

	{

	//-- check if the version aVer is supported

    if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber),aVer))

		return KErrNotSupported;

    return KErrNone;

	}

//-----------------------------------------------------------------------------------

/**

	Requests processing function.

	@return     request processing error code.

*/

TInt DKPLoggerTestHelperLDD::Request(TInt aFunction, TAny* a1, TAny* a2)

	{

    TInt nRes = KErrNone;

	if (aFunction == KMaxTInt)

		{//-- this is DoCancel()

        TUint reqMask = (TUint)a1;

        DoCancel(reqMask);

		return KErrNone;

		}

    if(aFunction < 0)

		{//-- This is DoRequest()

        //-- extract request parameters

        TRequestStatus* pRqStat=(TRequestStatus*)a1;

        TAny* params[2];

        kumemget32(params, a2, sizeof(params));

        nRes = DoRequest(~aFunction, pRqStat, params[0], params[1]); 

		}

    else

		{//-- This is DoControl()

        nRes = DoControl(aFunction, a1, a2);

		}

    return nRes;

	}

//-----------------------------------------------------------------------------------

/**

	Cancel outstanding request(s)

	@param  aReqNumber	request number to cancel

*/

void DKPLoggerTestHelperLDD::DoCancel(TUint aReqNumber)

	{

    switch (aReqNumber)

		{

		//-- cancel logging from ISR.

		case RKPLoggerTestHelper::EDoLogFromISR:  

			iIsrLogTicker.Cancel();

			break;

			//-- cancel logging from IDFC.

		case RKPLoggerTestHelper::EDoLogFromIDFC: 

			iIDfcLogTicker.Cancel();

			break;

			//-- cancel logging from DFC.

		case RKPLoggerTestHelper::EDoLogFromDFC:  

			iDfcLogTicker.Cancel();

			break;

		default:

			__PRINT1("#KPLogTest:DKPLoggerTestHelperLDD::DoCancel Cancelling a wrong request number:%d!", aReqMask);

			Kern::PanicCurrentThread(KPLoggerHelperTestDrv, EWrongRequest);

			break;

		}

	}

//-----------------------------------------------------------------------------------

/**

	Asynchronous request processing. 

	@param aFunction    request function number, see RKPLoggerTestHelper::TControl

    @param apRqStat     pointer to the user's request status object.

    @param apArg1       pointer to the 1st parameter in RKPLoggerTestHelper::DoRequest

    @param apArg2       pointer to the 2nd parameter in RKPLoggerTestHelper::DoRequest

	@return request scheduling result, system-wide error code.

*/

TInt DKPLoggerTestHelperLDD::DoRequest(TInt aReqNumber, TRequestStatus* aRqStat, TAny* aArg1, TAny* /*apArg2*/)

	{

    switch (aReqNumber)

		{

		//-- make logging from ISR.

		case RKPLoggerTestHelper::EDoLogFromISR:  

			{   

			__PRINT("#KPLogTest: making loggings from ISR context");

			iIsrLogTicker.Start((const TTestLogCtrl*)aArg1, aRqStat);

			}

			break;

			//-- make logging from IDFC.

		case RKPLoggerTestHelper::EDoLogFromIDFC: 

			{   

			__PRINT("#KPLogTest: making loggings from IDFC context");			

			iIDfcLogTicker.Start((const TTestLogCtrl*)aArg1, aRqStat);

			}			

			break;

			//-- make logging from DFC.

		case RKPLoggerTestHelper::EDoLogFromDFC:  

			{   

			__PRINT("#KPLogTest: making loggings from DFC context");			

			iDfcLogTicker.Start((const TTestLogCtrl*)aArg1, aRqStat);

			}

			break;

		default:

			__PRINT1("#KPLogTest:DKPLoggerTestHelperLDD::DoRequest() Wrong request number:%d!", aReqNumber);

			Kern::PanicCurrentThread(KPLoggerHelperTestDrv, EWrongRequest);

			break;

		}

    return KErrNone;

	}

//-----------------------------------------------------------------------------------

/**

	Synchronous requests processing. 

	@param aFunction    request function number, see RKernPerfLogger::TControl

	@param apArg1       pointer to the 1st parameter in RKernPerfLogger::DoControl

	@param apArg2       pointer to the 2n parameter in RKernPerfLogger::DoControl 

    @return request processing result

*/

TInt DKPLoggerTestHelperLDD::DoControl(TInt aFunction, TAny* aArg1, TAny* /*apArg2*/)

	{

    switch (aFunction)

		{

        //-- make test logging from the user thread

        case RKPLoggerTestHelper::EDoLogFromUserThread:

			{    

            kumemget32(&iLogControlUserThread, aArg1, sizeof(iLogControlUserThread)); //-- copy control structure from the user side

            __PRINT1("#KPLogTest: making %d loggings from a user-thread context", iLogControlUserThread.iLogsNum);

            __NK_ASSERT_DEBUG(iLogControlUserThread.iLogsNum >=0 );

            //-- This context is actually, a user thread. Make logging from here

            for(TInt i=0; i<iLogControlUserThread.iLogsNum; ++i)

				{

                //-- category field is ignored, it will be FastTrace::EKernPerfLog

                PERF_LOG(iLogControlUserThread.iSubCategory, iLogControlUserThread.iUserData, iLogControlUserThread.iUserData2);

                NKern::Sleep(iLogControlUserThread.iLogPeriodTick);

				}

			}

			break;

		//-- unit test for different PERF_LOG macros

        case RKPLoggerTestHelper::EDoTestMacros:

			{

            kumemget32(&iLogControlUserThread, aArg1, sizeof(iLogControlUserThread)); //-- copy control structure from the user side

            __PRINT1("#KPLogTest: making %d loggings from a user-thread context, testing different macros", iLogControlUserThread.iLogsNum);

            __NK_ASSERT_DEBUG(iLogControlUserThread.iLogsNum >=0 );

            for(TInt i=0; i<iLogControlUserThread.iLogsNum; ++i)

				{

                PERF_LOG0(iLogControlUserThread.iSubCategory);

                PERF_LOG1(iLogControlUserThread.iSubCategory, iLogControlUserThread.iUserData);

                PERF_LOG (iLogControlUserThread.iSubCategory, iLogControlUserThread.iUserData, iLogControlUserThread.iUserData2);

                NKern::Sleep(iLogControlUserThread.iLogPeriodTick);

				}

			}

			break;

        default:

			__PRINT1("#KPLogTest:DKPLoggerTestHelperLDD::DoControl() Wrong function number:%d!", aFunction);

			Kern::PanicCurrentThread(KPLoggerHelperTestDrv, EWrongRequest);

			break;

		};

    return KErrNone;

	}

//###################################################################################

//#            LDD factory, DKPLoggerTestHelperLDDFactory class implementation 

//###################################################################################

DKPLoggerTestHelperLDDFactory::DKPLoggerTestHelperLDDFactory()

	{

    iUnitsMask = 0x00; //-- don't support units

    iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);	

	}

DKPLoggerTestHelperLDDFactory::~DKPLoggerTestHelperLDDFactory()

	{

    __PRINT("#KPLogTest:~DKPLoggerTestHelperLDDFactory()");

	}

//-----------------------------------------------------------------------------------

/**

	static factory function for the LDD factory.

	@return pointer to the created instance of the class

*/

DKPLoggerTestHelperLDDFactory* DKPLoggerTestHelperLDDFactory::CreateInstance()

	{

    __PRINT("#KPLogTest:DKPLoggerTestHelperLDDFactory::CreateInstance()");

    //-- create LDD factory

    DKPLoggerTestHelperLDDFactory* pSelf = new DKPLoggerTestHelperLDDFactory;

    if(!pSelf)

		{//-- OOM 

        __PRINT("#KPLogTest:DKPLoggerTestHelperLDDFactory::CreateInstance(): Unable to create class instance !");

		}

    return pSelf;

	}

//-----------------------------------------------------------------------------------

/**

*/

TInt DKPLoggerTestHelperLDDFactory::Install()

	{

    return SetName(&KPLoggerHelperTestDrv); // Set our name and return error code

	}

//-----------------------------------------------------------------------------------

/**

*/

void DKPLoggerTestHelperLDDFactory::GetCaps(TDes8& /*aDes*/) const

	{//-- not supported

	}

//-----------------------------------------------------------------------------------

/**

	LDD factory function. Creates LDD object.

	@param  aChannel    A pointer to an LDD channel object which will be initialised on return.

	@return KErrNone    if object successfully allocated, KErrNoMemory if not.

	@return KErrAlreadyExists	if the client tries to creae more than 1 instance of the channel

*/

TInt DKPLoggerTestHelperLDDFactory::Create(DLogicalChannelBase*& aChannel)

	{

	if(DKPLoggerTestHelperLDD::pSelf)

		{//-- channel is a singleton, can't have more than one instance

        __PRINT("#DKPLoggerTestHelperLDDFactory::Create: Attmpt to create another instance of the LDD!");

        return KErrAlreadyExists;

		}

	aChannel = DKPLoggerTestHelperLDD::CreateInstance();

    if(!aChannel)

        return KErrNoMemory;  

    return KErrNone;

	}

//-----------------------------------------------------------------------------------

/**

	"Standard LDD" entrypoint.

	Is called on CreateLogicalDevice() if the user calls LoadLogicalDevice(). Creates LDD factory.

	@return pointer to the LDD factory object.

*/

DECLARE_STANDARD_LDD()

	{

    DKPLoggerTestHelperLDDFactory* pLDDFactory = DKPLoggerTestHelperLDDFactory::CreateInstance();

    return  pLDDFactory;

	}