// Copyright (c) 2003-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:
// e32test\personality\example\init.cpp
// Test code for example RTOS personality.
// 
//

#include <kernel/kern_priv.h>
#include <personality/example/personality.h>
#include <personality/example/personality_int.h>
#include "ifcldd.h"

#define	OC_TASK			0

#define MSG_ID_INIT		1
#define MSG_ID_RUN		2
#define MSG_ID_RUN_P	3
#define	MSG_ID_RND_ISR	4
#define MSG_ID_DONE		5
#define	MSG_ID_DATA		6
#define	MSG_ID_FLUSH	7
#define MSG_ID_SEM_RPT	8
#define MSG_ID_RCV_RPT	9
#define MSG_ID_TM_RPT	10

typedef struct _random_isr_msg
	{
	msghdr			header;
	unsigned		random_isr_number;
	unsigned		extra;
	} random_isr_msg;

typedef struct _data_msg
	{
	msghdr			header;
	int				length;
	unsigned char	checksum;
	unsigned char	data[1];
	} data_msg;

typedef struct _report_msg
	{
	msghdr			header;
	int				pad;
	unsigned		count;
	unsigned		ok_count;
	unsigned		bad_count;
	} report_msg;

const TInt KMajorVersionNumber=0;
const TInt KMinorVersionNumber=1;
const TInt KBuildVersionNumber=1;

void RxMsg(TAny* aPtr);

TPMsgQ ThePMsgQ(&RxMsg, 0, Kern::DfcQue0(), 7);

NONSHARABLE_CLASS(DRtosIfcFactory) : public DLogicalDevice
	{
public:
	DRtosIfcFactory();
	virtual TInt Install();						//overriding pure virtual
	virtual void GetCaps(TDes8& aDes) const;	//overriding pure virtual
	virtual TInt Create(DLogicalChannelBase*& aChannel);	//overriding pure virtual
	};

class TRxQ
	{
public:
	TRxQ(DThread* aThread) : iFirst(0), iLast(0), iStatus(0), iPtr(0), iThread(aThread) {}
	TInt QueueReq(TRequestStatus* aStatus, TAny* aPtr);
	void AddMsg(msghdr* aM);
	inline TBool MsgPresent() {return iFirst!=NULL;}
	void CompleteReq();
	void CancelReq();
	void Close();
public:
	msghdr* iFirst;
	msghdr* iLast;
	TRequestStatus* iStatus;
	TAny* iPtr;
	DThread* iThread;
	};

TInt TRxQ::QueueReq(TRequestStatus* aStatus, TAny* aPtr)
	{
	if (iStatus)
		return KErrInUse;
	iStatus = aStatus;
	iPtr = aPtr;
	if (iFirst)
		CompleteReq();
	return KErrNone;
	}

void TRxQ::AddMsg(msghdr* aM)
	{
	aM->next = NULL;
	if (iLast)
		iLast->next = aM;
	else
		iFirst = aM;
	iLast = aM;
	if (iStatus)
		CompleteReq();
	}

void TRxQ::CompleteReq()
	{
	msghdr* m = iFirst;
	iFirst = m->next;
	if (!iFirst)
		iLast = NULL;
	TInt r = KErrNone;
	switch (m->msg_id)
		{
		case MSG_ID_DATA:
			{
			data_msg* dm = (data_msg*)m;
			r = Kern::ThreadRawWrite(iThread, iPtr, &dm->length, dm->length + 5, iThread);
			break;
			}
		case MSG_ID_SEM_RPT:
		case MSG_ID_RCV_RPT:
		case MSG_ID_TM_RPT:
			{
			report_msg* rpt = (report_msg*)m;
			rpt->pad = m->msg_id;
			r = Kern::ThreadRawWrite(iThread, iPtr, &rpt->pad, sizeof(SReport), iThread);
			break;
			}
		default:
			break;
		}
	free_mem_block(m);
	Kern::RequestComplete(iThread, iStatus, r);
	iStatus = NULL;
	}

void TRxQ::CancelReq()
	{
	if (iStatus)
		Kern::RequestComplete(iThread, iStatus, KErrCancel);
	iStatus = NULL;
	}

void TRxQ::Close()
	{
	CancelReq();
	while (iFirst)
		{
		msghdr* m = iFirst;
		iFirst = m->next;
		free_mem_block(m);
		}
	iFirst = NULL;
	iLast = NULL;
	}

NONSHARABLE_CLASS(DRtosIfc) : public DLogicalChannel
	{
public:
	DRtosIfc();
	virtual ~DRtosIfc();
protected:
	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);
	virtual void HandleMsg(TMessageBase* aMsg);
public:
	TInt DoControl(TInt aFunc, TAny* a1, TAny* a2);
	TInt DoRequest(TInt aFunc, TRequestStatus* aStatus, TAny* a1, TAny* a2);
	void DoCancel(TInt aMask);
	void HandleRtosMsg(msghdr* aMsg);
public:
	DThread* iThread;
	TRequestStatus* iDoneStatus;
	TRxQ iRxQ;
	TRxQ iRptQ;
	};

void RxMsg(TAny* aPtr)
	{
	msghdr* m = ThePMsgQ.Get();
	((DRtosIfc*)aPtr)->HandleRtosMsg(m);
	}

TInt EntryPoint()
	{
	TPMsgQ::ThePMsgQ = &::ThePMsgQ;
	init_personality();

	assert(current_task_id() == TASK_ID_UNKNOWN);

	kprintf("Entry point exit");

	return 0;
	}

void SendInitMsg()
	{
	kprintf("Send init msg");
	msghdr* m = (msghdr*)alloc_mem_block(sizeof(msghdr));
	m->msg_id = MSG_ID_INIT;
	int r = send_msg(OC_TASK, m);
	assert(r == OK);
	}

void SendFlushMsg()
	{
	msghdr* m = (msghdr*)alloc_mem_block(sizeof(msghdr));
	m->msg_id = MSG_ID_FLUSH;
	int r = send_msg(OC_TASK, m);
	assert(r == OK);
	}

void SendFinishMsg()
	{
	msghdr* m = (msghdr*)alloc_mem_block(sizeof(msghdr));
	m->msg_id = MSG_ID_DONE;
	int r = send_msg(OC_TASK, m);
	assert(r == OK);
	}

DRtosIfcFactory::DRtosIfcFactory()
	{
    iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);
    //iParseMask=0;//No units, no info, no PDD
    //iUnitsMask=0;//Only one thing
	}

TInt DRtosIfcFactory::Create(DLogicalChannelBase*& aChannel)
    {
	aChannel = new DRtosIfc;
    return aChannel ? KErrNone : KErrNoMemory;
    }

TInt DRtosIfcFactory::Install()
	{
	TInt r = SetName(&KRtosIfcLddName);
#ifndef __EPOC32__
	if (r == KErrNone)
		r = EntryPoint();
#endif
	return r;
	}

void DRtosIfcFactory::GetCaps(TDes8& aDes) const
    {
    TCapsRtosIfcV01 b;
    b.iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);
    Kern::InfoCopy(aDes,(TUint8*)&b,sizeof(b));
    }

DRtosIfc::DRtosIfc()
	:	iRxQ(&Kern::CurrentThread()),
		iRptQ(&Kern::CurrentThread())
    {
	iThread=&Kern::CurrentThread();
	iThread->Open();
    }

DRtosIfc::~DRtosIfc()
	{
	iRxQ.Close();
	iRptQ.Close();
	Kern::SafeClose((DObject*&)iThread, NULL);
	}

TInt DRtosIfc::DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer)
//
// Create channel
//
    {

    if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber),aVer))
    	return KErrNotSupported;
	if (ThePMsgQ.iPtr)
		return KErrInUse;
	SetDfcQ(Kern::DfcQue0());
	iMsgQ.Receive();
	ThePMsgQ.iPtr = this;
	ThePMsgQ.Receive();
	return KErrNone;
	}

void DRtosIfc::HandleMsg(TMessageBase* aMsg)
	{
	TThreadMessage& m=*(TThreadMessage*)aMsg;
	TInt id=m.iValue;
	if (id==(TInt)ECloseMsg)
		{
		ThePMsgQ.CancelReceive();
		ThePMsgQ.iPtr = NULL;
		m.Complete(KErrNone,EFalse);
		iMsgQ.CompleteAll(KErrServerTerminated);
		return;
		}
	else if (id==KMaxTInt)
		{
		// DoCancel
		DoCancel(m.Int0());
		m.Complete(KErrNone,ETrue);
		return;
		}

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

TInt DRtosIfc::DoControl(TInt aFunc, TAny* a1, TAny* a2)
	{
	(void)a1;
	(void)a2;
	TInt r = KErrNone;
	switch (aFunc)
		{
		case RRtosIfc::EControlInit:
			SendInitMsg();
			break;
		case RRtosIfc::EControlFlush:
			SendFlushMsg();
			break;
		case RRtosIfc::EControlFinish:
			SendFinishMsg();
			break;
		case RRtosIfc::EControlSend:
			{
			data_msg* dm = (data_msg*)alloc_mem_block(512);
			TPtr8 lptr(dm->data, 0, 516-sizeof(data_msg));
			r = Kern::ThreadDesRead(iThread, a1, lptr, 0, 0);
			if (r == KErrNone)
				{
				dm->header.msg_id = MSG_ID_DATA;
				dm->length = lptr.Length();
				dm->checksum = 0;
				send_msg(OC_TASK, &dm->header);
				}
			else
				free_mem_block(dm);
			break;
			}
		default:
			r = KErrNotSupported;
			break;
		}
	return r;
	}

TInt DRtosIfc::DoRequest(TInt aFunc, TRequestStatus* aStatus, TAny* a1, TAny* a2)
	{
	(void)a1;
	(void)a2;
	switch (aFunc)
		{
		case RRtosIfc::ERequestWaitInitialTests:
			iDoneStatus = aStatus;
			return KErrNone;
		case RRtosIfc::ERequestReceive:
			return iRxQ.QueueReq(aStatus, a1);
		case RRtosIfc::ERequestReport:
			return iRptQ.QueueReq(aStatus, a1);
		default:
			return KErrNotSupported;
		}
	}

void DRtosIfc::DoCancel(TInt aMask)
	{
	if (aMask & RRtosIfc::ECancelWaitInitialTests)
		{
		Kern::RequestComplete(iThread, iDoneStatus, KErrCancel), iDoneStatus=NULL;
		}
	if (aMask & RRtosIfc::ECancelReceive)
		iRxQ.CancelReq();
	if (aMask & RRtosIfc::ECancelReport)
		iRptQ.CancelReq();
	}

void DRtosIfc::HandleRtosMsg(msghdr* aM)
	{
	switch (aM->msg_id)
		{
		case MSG_ID_DONE:
			if (iDoneStatus)
				Kern::RequestComplete(iThread, iDoneStatus, KErrNone), iDoneStatus=NULL;
			break;
		case MSG_ID_DATA:
			iRxQ.AddMsg(aM);
			aM = NULL;
			break;
		case MSG_ID_SEM_RPT:
		case MSG_ID_RCV_RPT:
		case MSG_ID_TM_RPT:
			iRptQ.AddMsg(aM);
			aM = NULL;
			break;
		default:
			break;
		}
	if (aM)
		free_mem_block(aM);
	ThePMsgQ.Receive();
	}

#ifdef __EPOC32__
DECLARE_STANDARD_EXTENSION()
	{
	return EntryPoint();
	}

DECLARE_EXTENSION_LDD()
	{
	return new DRtosIfcFactory;
	}
#else
DECLARE_STANDARD_LDD()
	{
	return new DRtosIfcFactory;
	}
#endif