/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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: 

*

*/

#ifdef __WINS__

#error - this driver cannot be built for emulation

#endif

#include <e32def.h>

#include <e32cmn.h>

#include <kernel.h>

#include <kern_priv.h>

#include <arm.h>

#include "TrkXtiComm.h"

#include "TrkXtiDriver.h"

#define KTrkAppSecurUid 0x200170BB

#define KTrkExeSecurUid 0x200159E2

//

// Static function definitions

//

//

//

// DTrkXtiDriverFactory implementation

//

//

//

// DTrkXtiDriverFactory constructor

//

DTrkXtiDriverFactory::DTrkXtiDriverFactory()

{

    iVersion = TVersion(KMajorXtiVersionNumber, KMinorXtiVersionNumber, KBuildXtiVersionNumber);    

}

//

// DTrkXtiDriverFactory::Create

//

TInt DTrkXtiDriverFactory::Create(DLogicalChannelBase*& aChannel)

{

	if (iOpenChannels != 0)

		return KErrInUse; // a channel is already open

	aChannel = new DTrkXtiChannel(this);

	return aChannel ? KErrNone : KErrNoMemory;

}

//

// DTrkXtiDriverFactory::Install

//

TInt DTrkXtiDriverFactory::Install()

{

    return(SetName(&KTrkXtiDriverName));

}

//

// DTrkXtiDriverFactory::Install

//

void DTrkXtiDriverFactory::GetCaps(TDes8& aDes) const

{

    TCapsTrkXtiDriver b;

    b.iVersion = TVersion(KMajorXtiVersionNumber, KMinorXtiVersionNumber, KBuildXtiVersionNumber);

    Kern::InfoCopy(aDes,(TUint8*)&b, sizeof(b));

}

//

//

// DTrkXtiChannel implementation

//

//

//

// DTrkXtiChannel constructor

//

DTrkXtiChannel::DTrkXtiChannel(DLogicalDevice* aLogicalDevice)

					: iRxPendingMsg(EFalse),

					  iInterruptId(76)

{

	LOG_MSG("DTrkXtiChannel::DTrkXtiChannel()");

	iDevice = aLogicalDevice;

	iClientThread = &Kern::CurrentThread();

	TInt err = iClientThread->Open();	

	LOG_MSG("DTrkXtiChannel::DTrkXtiChannel() End"); 

}

//

// DTrkXtiChannel destructor

//

DTrkXtiChannel::~DTrkXtiChannel()

{

	LOG_MSG("DTrkXtiChannel::~DTrkXtiChannel()");

	Kern::SafeClose((DObject*&)iClientThread, NULL);

	if (iLock)

		iLock->Close(NULL);	

}

//

// DTrkXtiChannel::DoCreate

//

TInt DTrkXtiChannel::DoCreate(TInt /*aUnit*/, const TDesC* /*anInfo*/, const TVersion& aVer)

{

	LOG_MSG("DTrkXtiChannel::DoCreate()");

  	if (!Kern::QueryVersionSupported(TVersion(KMajorXtiVersionNumber, KMinorXtiVersionNumber, KBuildXtiVersionNumber), aVer))

		return KErrNotSupported; 

	//Setup the driver for receiving client messages

	iDFCQue = NULL;

	TBuf8<KMaxInfoName> xtiDFC = _L8("XTI DFC");;

	TInt err = Kern::DfcQCreate(iDFCQue, 27, &xtiDFC);

	if (err == KErrNone)

	{

		SetDfcQ(iDFCQue);

	}

	else

	{

		SetDfcQ(Kern::DfcQue0());

	}

	iMsgQ.Receive();  	

	// create subscriber and subscribe to receive trk messages from TraceCore

	iTrkXtiSubscriber = new DTrkXtiSubscriber;

 	if (!iTrkXtiSubscriber)

		return KErrNoMemory;

	err = iTrkXtiSubscriber->Create(this, iClientThread);

	if (err != KErrNone)

		return err;

	err = Kern::SemaphoreCreate(iLock, _L("TrkXtiDriverWriteLock"), 1 /* Initial count */);

	if (err != KErrNone)

		return err;

	return KErrNone;

}

//

// DTrkXtiChannel::DoCancel

//

void DTrkXtiChannel::DoCancel(TInt aReqNo)

{

	LOG_MSG("DTrkXtiChannel::DoCancel()");

	switch(aReqNo)

	{

		case RTrkXtiDriver::ERequestReadCancel:

		{

			Kern::RequestComplete(iClientThread, iRxRequestStatus, KErrCancel);

			iRxClientBuffer = NULL;

			iRxRequestStatus = NULL;

			iRxClientBufferLength = 0;

		}

		break;

	}

}

//

// DTrkXtiChannel::DoRequest

//

void DTrkXtiChannel::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)

{

	LOG_MSG("DTrkXtiChannel::DoRequest()");

	switch(aReqNo)

	{

		case RTrkXtiDriver::ERequestRead:

		{

			iRxRequestStatus = aStatus;

			iRxClientBuffer = a1;

			iRxClientBufferLength = (TUint32)a2;

			if (iRxPendingMsg)

			{

				TInt err = Kern::ThreadDesWrite(iClientThread, iRxClientBuffer, iRxPendingMsgBuffer, 0, KChunkShiftBy0, iClientThread);

				Kern::RequestComplete(iClientThread, iRxRequestStatus, err);

				iRxRequestStatus = NULL;

				iRxPendingMsg = EFalse;

			}

			break;

		}		

		default:

			Kern::RequestComplete(iClientThread, aStatus, KErrNotSupported);

	}

}

//

// DTrkXtiChannel::DoControl

//

TInt DTrkXtiChannel::DoControl(TInt aFunction, TAny* a1, TAny* a2)

{

	LOG_MSG("DTrkXtiChannel::DoControl()");

	TInt err = KErrNone;

	switch(aFunction)

	{

		case RTrkXtiDriver::EControlWrite:

		{

			//lock the Semaphore so that write doesn't happen when a write is already in progress.

			Kern::SemaphoreWait(*iLock);

			err = DoWrite((TUint32)a1, a2);			

			Kern::SemaphoreSignal(*iLock);			

			break;

		}

		default:

		{

			return KErrGeneral;

		}

	}

	if (KErrNone != err)

	{

		LOG_MSG2("Error %d from control function", err);

	}

	return err;

}

//

// DTrkXtiChannel::HandleMsg

//

void DTrkXtiChannel::HandleMsg(TMessageBase* aMsg)

{

	LOG_MSG("DTrkXtiChannel::HandleMsg()");

	TThreadMessage& m = *(TThreadMessage*)aMsg;

	TInt id = m.iValue;

	if (id == (TInt)ECloseMsg)

	{

        if (iTrkXtiSubscriber)

        {

            Kern::SemaphoreWait(*iLock);

            delete iTrkXtiSubscriber;

            iTrkXtiSubscriber = NULL;   

            Kern::SemaphoreSignal(*iLock);              

        }

		m.Complete(KErrNone, EFalse);

		return;

	}

	if (id == KMaxTInt)

	{

		// DoCancel

		DoCancel(m.Int0());

		m.Complete(KErrNone, ETrue); 

		return;

	}

	if (id < 0)

	{

		// DoRequest

		TRequestStatus* pStatus = (TRequestStatus*)m.Ptr0();

		DoRequest(~id, pStatus, m.Ptr1(), m.Ptr2());

		m.Complete(KErrNone, ETrue);

	}

	else

	{

		// DoControl

		TInt err = DoControl(id, m.Ptr0(), m.Ptr1());

		m.Complete(err, ETrue);

	}

}

//

// DTrkXtiChannel::DoWrite

//

TInt DTrkXtiChannel::DoWrite(TUint32 aLength, TAny* a2)

{

	LOG_MSG("DTrkXtiChannel::DoWrite()");

	TInt err = KErrNone;

	err = Kern::ThreadDesRead(iClientThread, a2, iTxBuffer, 0, KChunkShiftBy0);

	if (err == KErrNone)

	{	

		err = WriteXtiChannel(iTxBuffer);

	}

	return err;

}

//

// DTrkXtiChannel::WriteXtiChannel

//

// This function writes all the data in the descriptor in one message

TInt DTrkXtiChannel::WriteXtiChannel(TDesC8& aDes)

{

	TInt err = KErrNone;

		err = iTrkXtiSubscriber->Send(aDes);

	return err;

}

//

// DTrkXtiChannel::DoCompleteRx

//

void DTrkXtiChannel::DoCompleteRx(const TDesC8& aMessage)

{

	LOG_MSG("DTrkXtiChannel::DoCompleteRx()");

	// If there is a pending read request, complete the request with this message.

	// Otherwise store the message, ideally we should queue the messages, but having 

	// a large buffer is failing to initialize at the startup.

	// For now, we will just store only one message

	// If for some reason, TRK is waiting on something and doesn't read for a while, 

	// then its possible that we will loose messages. 

	Kern::SemaphoreWait(*iLock);

	if (iRxRequestStatus)

	{

		TInt err = Kern::ThreadDesWrite(iClientThread, iRxClientBuffer, aMessage, 0, KChunkShiftBy0, iClientThread);

		Kern::RequestComplete(iClientThread, iRxRequestStatus, err);

		iRxRequestStatus = NULL;

	}

	else if (!iRxPendingMsg)

	{

		iRxPendingMsgBuffer.Copy(aMessage);

		iRxPendingMsg = ETrue;

	}

	Kern::SemaphoreSignal(*iLock);

}

DECLARE_STANDARD_LDD()

{

    return new DTrkXtiDriverFactory;

}