// Copyright (c) 2010 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:
// d_timestamp.cpp
//

#include <kern_priv.h>
#include <kernel.h>
#include "d_timestamp.h"
#include "d_timestamp_dev.h"

// time stamp test defaults
static const TInt KTimerDurationS = 5;  // time interval for NTimer
static const TInt KNErrPercent = 1;  // percent error acceptable
static const TInt KIterations = 5;  // required number of valid runs (with LPM entry) 
static const TInt KRetries = 4;  // retries are reset on every succesful run

//
// DTimestampTestFactory
//

/**
   Standard export function for LDDs. This creates a DLogicalDevice derived object,
   in this case, our DTimestampTestFactory
*/
DECLARE_STANDARD_LDD()
	{
	return new DTimestampTestFactory;
	}

/**
   Constructor
*/
DTimestampTestFactory::DTimestampTestFactory()
	{
	// Set version number for this device
	iVersion=RTimestampTest::VersionRequired();
    // Indicate that we work with a PDD
	iParseMask=KDeviceAllowPhysicalDevice;
    }

/**
   Second stage constructor for DTimestampTestFactory.
   This must at least set a name for the driver object.

   @return KErrNone if successful, otherwise one of the other system wide error codes.
*/
TInt DTimestampTestFactory::Install()
	{
	return SetName(&RTimestampTest::Name());
	}

/**
   Destructor
*/
DTimestampTestFactory::~DTimestampTestFactory()
	{
    
    }

/**
   Return the drivers capabilities.
   Called in the response to an RDevice::GetCaps() request.

   @param aDes User-side descriptor to write capabilities information into
*/
void DTimestampTestFactory::GetCaps(TDes8& aDes) const
	{
	// Create a capabilities object
	RTimestampTest::TCaps caps;
	caps.iVersion = iVersion;
	// Write it back to user memory
	Kern::InfoCopy(aDes,(TUint8*)&caps,sizeof(caps));
	}


/**
   Called by the kernel's device driver framework to create a Logical Channel.
   This is called in the context of the user thread (client) which requested the creation of a Logical Channel
   (E.g. through a call to RBusLogicalChannel::DoCreate)
   The thread is in a critical section.

   @param aChannel Set to point to the created Logical Channel

   @return KErrNone if successful, otherwise one of the other system wide error codes.
*/
TInt DTimestampTestFactory::Create(DLogicalChannelBase*& aChannel)
	{
	aChannel=new DTimestampTestChannel;
	if(!aChannel)
        {
		return KErrNoMemory;
        }
    
	return KErrNone;
	}


//
// Logical Channel
//

/**
   Constructor
*/
DTimestampTestChannel::DTimestampTestChannel()
    :iTimer(timerExpire,this),iDfc(dfcFn,this,7),iStarted(EFalse)
	{
	// Get pointer to client threads DThread object
	iClient=&Kern::CurrentThread();
	// Open a reference on client thread so it's control block can't dissapear until
	// this driver has finished with it.
	// Note, this call to Open can't fail since its the thread we are currently running in
	iClient->Open();
	}

/**
   Second stage constructor called by the kernel's device driver framework.
   This is called in the context of the user thread (client) which requested the creation of a Logical Channel
   (E.g. through a call to RBusLogicalChannel::DoCreate)
   The thread is in a critical section.

   @param aUnit The unit argument supplied by the client to RBusLogicalChannel::DoCreate
   @param aInfo The info argument supplied by the client to RBusLogicalChannel::DoCreate
   @param aVer The version argument supplied by the client to RBusLogicalChannel::DoCreate

   @return KErrNone if successful, otherwise one of the other system wide error codes.
*/
TInt DTimestampTestChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer)
	{
	// Check version
	if (!Kern::QueryVersionSupported(RTimestampTest::VersionRequired(),aVer))
		return KErrNotSupported;

	// Setup LDD for receiving client messages
    TInt r = Kern::CreateClientRequest(iStartRequest);
    if (r != KErrNone) return r;
    r = Kern::CreateClientDataRequest(iWaitOnTimerRequest);
    if (r != KErrNone) return r;
    r = Kern::DynamicDfcQCreate(iQue,Kern::DfcQue0()->iThread->iPriority,RTimestampTest::Name());
    if (KErrNone!=r) return r;
    iDfc.SetDfcQ(iQue);
    SetDfcQ(iQue);
    iMsgQ.Receive();
    // Done
	return KErrNone;
	}


/**
   Destructor
*/
DTimestampTestChannel::~DTimestampTestChannel()
	{
	// Cancel all processing that we may be doing
	DoCancel(TUint(RTimestampTest::EAllRequests));
    Kern::DestroyClientRequest(iWaitOnTimerRequest);
    Kern::DestroyClientRequest(iStartRequest);
    iQue->Destroy();
	// Close our reference on the client thread
	Kern::SafeClose((DObject*&)iClient,NULL);
	}

/**
   Called when a user thread requests a handle to this channel.
*/
TInt DTimestampTestChannel::RequestUserHandle(DThread* aThread, TOwnerType aType)
	{
	// Make sure that only our client can get a handle
	if (aType!=EOwnerThread || aThread!=iClient)
		return KErrAccessDenied;
	return KErrNone;
	}

/**
   override SendMsg method to allow pinning data in the context of the client thread
*/
TInt DTimestampTestChannel::SendMsg(TMessageBase* aMsg)
	{
	TThreadMessage& m=*(TThreadMessage*)aMsg;
    TInt id = m.iValue;

	// we only support one client
	if (id != (TInt)ECloseMsg && m.Client() != iClient)
		return KErrAccessDenied;
	
	TInt r = KErrNone;
	if (id != (TInt)ECloseMsg && id != KMaxTInt)
		{
		if (id<0)
			{
			TRequestStatus* pS=(TRequestStatus*)m.Ptr0();
			r = SendRequest(aMsg);
			if (r != KErrNone)
				Kern::RequestComplete(pS,r);
			}
		else
			r = SendControl(aMsg);
		}
	else
		r = DLogicalChannel::SendMsg(aMsg);
	
	return r;
	}

/**
   Process a message for this logical channel.
   This function is called in the context of a DFC thread.

   @param aMessage The message to process.
   The iValue member of this distinguishes the message type:
   iValue==ECloseMsg, channel close message
   iValue==KMaxTInt, a 'DoCancel' message
   iValue>=0, a 'DoControl' message with function number equal to iValue
   iValue<0, a 'DoRequest' message with function number equal to ~iValue
*/
void DTimestampTestChannel::HandleMsg(TMessageBase* aMsg)
	{
	TThreadMessage& m=*(TThreadMessage*)aMsg;

	// Get message type
	TInt id=m.iValue;

	// Decode the message type and dispatch it to the relevent handler function...

	if (id==(TInt)ECloseMsg)
		{
		// Channel Close
        DoCancel(TUint(RTimestampTest::EAllRequests));
        iMsgQ.CompleteAll(KErrServerTerminated);
		m.Complete(KErrNone, EFalse);
		return;
		}

	if (id==KMaxTInt)
		{
		// DoCancel
		DoCancel(m.Int0());
		m.Complete(KErrNone,ETrue);
		return;
		}

	if (id<0)
		{
		// DoRequest
		TRequestStatus* pS=(TRequestStatus*)m.Ptr0();
		DoRequest(~id,pS,m.Ptr1(),m.Ptr2());
		m.Complete(KErrNone,ETrue);
		}
	else
		{
		// DoControl
		TInt r=DoControl(id,m.Ptr0(),m.Ptr1());
		m.Complete(r,ETrue);
		}
	}

/**
   Preprocess synchronous 'control' requests
*/
TInt DTimestampTestChannel::SendControl(TMessageBase* aMsg)
	{
	TThreadMessage& m=*(TThreadMessage*)aMsg;
    TInt id=m.iValue;

	switch (id)
		{
        
    case RTimestampTest::EConfig:
        {
        STimestampTestConfig info;
#ifdef __SMP__
        info.iFreq = NKern::TimestampFrequency();
#else
        info.iFreq = NKern::FastCounterFrequency();
#endif
        info.iIterations = KIterations;
        info.iRetries = KRetries;
        info.iTimerDurationS = KTimerDurationS;
        info.iErrorPercent = KNErrPercent;
        // Allow PDD to override defaults
        Pdd().TestConfig(info);
        kumemput(m.Ptr0(),&info,sizeof(STimestampTestConfig));
        return KErrNone;
		}
    
        }
    

	TInt r = DLogicalChannel::SendMsg(aMsg);
	if (r != KErrNone)
		return r;

// 	switch (id)
// 		{
// 		}

	return r;
	}

/**
   Process synchronous 'control' requests
*/
TInt DTimestampTestChannel::DoControl(TInt aFunction, TAny* a1, TAny* a2)
	{
	(void)a2;   
	(void)a1;   
	(void) aFunction;

	// TInt r = KErrNone;
	// switch (aFunction)
	// 	{
    // default:
    //     r = KErrNotSupported;
	// 	}

	return KErrNotSupported;
	}


/**
   Preprocess asynchronous requests.
*/
TInt DTimestampTestChannel::SendRequest(TMessageBase* aMsg)
    {
	TThreadMessage& m=*(TThreadMessage*)aMsg;
    TInt function = ~m.iValue;
    TRequestStatus* pS=(TRequestStatus*)m.Ptr0();
		
	TInt r = KErrNotSupported;

	switch (function)
		{
		case RTimestampTest::EStart:
            if (!iStarted) 
                {
                r = iStartRequest->SetStatus(pS);
                }
            else 
                {
                r = KErrInUse;
                }
            break;
            
		case RTimestampTest::EWaitOnTimer:
            if (iStarted)
                {
                iWaitOnTimerRequest->SetDestPtr(m.Ptr1());
                r = iWaitOnTimerRequest->SetStatus(pS);
                }
            else
                {
                r = KErrNotReady;
                }
            
            break;
        default:
            r = KErrNotSupported;
		}

	if (r == KErrNone)
		r = DLogicalChannel::SendMsg(aMsg);
	return r;
    }


/**
   Process asynchronous requests.
*/
void DTimestampTestChannel::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)
	{
	(void)a2;   
	(void)a1;   
    (void)aStatus;
    
	TInt r = KErrNone;

	switch(aReqNo)
		{
    case RTimestampTest::EStart:
        iNTicks = (TInt) a1;
        r = iTimer.OneShot(0);
        if (KErrNone!=r) Kern::QueueRequestComplete(iClient,iStartRequest,r);
        break;
    case RTimestampTest::EWaitOnTimer:
        Pdd().StartLPMEntryCheck();   // PDD will start checking if we have entered LPM
        r = iTimer.Again(iNTicks);
        if (KErrNone!=r) Kern::QueueRequestComplete(iClient,iWaitOnTimerRequest,r);
        break;
		}
    
	}



/**
   Process cancelling of asynchronous requests.
*/
void DTimestampTestChannel::DoCancel(TUint aMask)
	{
    (void)aMask;
    iTimer.Cancel(); // no real guarantees on SMP systems
    iDfc.Cancel();
	}


/**
 * process timer expiry
*/
void DTimestampTestChannel::DoTimerExpire()
	{
#ifdef __SMP__
    TUint64 ts = NKern::Timestamp();
#else
    TUint64 ts = NKern::FastCounter();
#endif
    iTimestampDelta = ts-iLastTimestamp;
    iLastTimestamp = ts;
    iDfc.Add();
	}

void DTimestampTestChannel::timerExpire(TAny* aParam)
    {
    DTimestampTestChannel* pD = (DTimestampTestChannel*) aParam;
    pD->DoTimerExpire();
    }



void DTimestampTestChannel::DoDfcFn()
	{
    if (!iStarted)
        {
        iStarted = ETrue;
        Kern::QueueRequestComplete(iClient,iStartRequest,KErrNone);
        }
    else
        {
        iWaitOnTimerRequest->Data().iDelta = iTimestampDelta;
        // PDD will return ETrue here if we have entered LPM
        iWaitOnTimerRequest->Data().iLPMEntered = Pdd().EndLPMEntryCheck(); 
        Kern::QueueRequestComplete(iClient,iWaitOnTimerRequest,KErrNone);
        }
	}

void DTimestampTestChannel::dfcFn(TAny* aParam)
    {
    DTimestampTestChannel* pD = (DTimestampTestChannel*) aParam;
    pD->DoDfcFn();
    }