// 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:

 // e32\personality\example\personality.cpp

 // Example RTOS personality.

 // 

 //

 #include "personality_int.h"

 /******************************************************************************

  * Memory pool management

  ******************************************************************************/

 // Create a single memory pool consisting of a specified number of equal sized blocks.

 TInt PMemPool::Create(const poolinfo* aInfo)

 	{

 	iBlockSize = aInfo->block_size;

 	TUint bsize = iBlockSize + sizeof(PMemPool*);

 	TInt n = (TInt)aInfo->block_count;

 	__KTRACE_OPT(KBOOT, Kern::Printf("PMemPool::Create %08x iBlockSize=%04x bsize=%04x n=%04x", this, iBlockSize, bsize, n));

 	if (bsize < sizeof(SMemBlock) || (bsize & 3))

 		return KErrArgument;

 	TInt total_size = n * bsize;

 	iFirstFree = (SMemBlock*)Kern::Alloc(total_size);

 	__KTRACE_OPT(KBOOT, Kern::Printf("PMemPool::Create %08x iFirstFree=%08x", this, iFirstFree));

 	if (!iFirstFree)

 		return KErrNoMemory;

 	TInt i;

 	for (i=0; i<n; ++i)

 		{

 		SMemBlock* p = (SMemBlock*)(TLinAddr(iFirstFree) + i*bsize);

 		SMemBlock* q = (i<n-1) ? (SMemBlock*)(TLinAddr(p) + bsize) : NULL;

 		p->iPool = this;

 		p->iNext = q;

 		}

 	__KTRACE_OPT(KBOOT, Kern::Printf("PMemPool::Create OK"));

 	return KErrNone;

 	}

 // Call with interrupts disabled

 void* PMemPool::Alloc()

 	{

 	SMemBlock* p = iFirstFree;

 	if (p)

 		{

 		iFirstFree = p->iNext;

 		__KTRACE_OPT(KBOOT, Kern::Printf("AL:%08x->%08x", this, &p->iNext));

 		return &p->iNext;

 		}

 	__KTRACE_OPT(KBOOT, Kern::Printf("AL:%08x->0", this));

 	return NULL;

 	}

 // Call with interrupts disabled

 void PMemPool::Free(void* aBlock)

 	{

 	__KTRACE_OPT(KBOOT, Kern::Printf("FR:%08x<-%08x", this, aBlock));

 	SMemBlock* b = (SMemBlock*)aBlock;

 	__NK_ASSERT_DEBUG(b->iPool==this);

 	b->iNext = iFirstFree;

 	iFirstFree = b;

 	}

 PMemMgr* PMemMgr::TheMgr;

 // Create a 'size bucket' memory manager consisting of a number of memory pools

 // each containing blocks of the same size. The block size increases from one

 // pool to the next.

 void PMemMgr::Create(const poolinfo* aInfo)

 	{

 	TInt n;

 	for (n=0; aInfo[n].block_size; ++n) {}

 	PMemMgr* m = (PMemMgr*)Kern::Alloc(sizeof(PMemMgr) + (n-1)*sizeof(PMemPool));

 	__KTRACE_OPT(KBOOT, Kern::Printf("PMemMgr::Create %08x NumPools=%d", m, n));

 	__NK_ASSERT_ALWAYS(m!=NULL);

 	m->iPoolCount = n;

 	TInt i;

 	size_t prev_sz=0;

 	for (i=0; i<n; ++i)

 		{

 		__NK_ASSERT_ALWAYS(aInfo[i].block_size > prev_sz);

 		prev_sz = aInfo[i].block_size;

 		TInt r = m->iPools[i].Create(aInfo+i);

 		__NK_ASSERT_ALWAYS(r==KErrNone);

 		}

 	TheMgr = m;

 	}

 // Allocate a memory block of the requested size (or the next larger size if necessary).

 void* PMemMgr::Alloc(size_t aSize)

 	{

 	__KTRACE_OPT(KBOOT, Kern::Printf("MA:%04x", aSize));

 	void* b = NULL;

 	PMemPool* p = &TheMgr->iPools[0];

 	PMemPool* q = p + TheMgr->iPoolCount;

 	for (; p<q && p->iBlockSize < aSize; ++p) {}

 	if (p < q)

 		{

 		TInt irq = NKern::DisableAllInterrupts();

 		b = p->Alloc();

 		NKern::RestoreInterrupts(irq);

 		}

 	return b;

 	}

 // Free a memory block

 void PMemMgr::Free(void* aPtr)

 	{

 	__KTRACE_OPT(KBOOT, Kern::Printf("MF:%08x", aPtr));

 	SMemBlock* b = _LOFF(aPtr, SMemBlock, iNext);

 	TInt irq = NKern::DisableAllInterrupts();

 	b->iPool->Free(b);

 	NKern::RestoreInterrupts(irq);

 	}

 /* Memory management APIs */

 extern "C" {

 void* alloc_mem_block(size_t size)

 	{

 	return PMemMgr::Alloc(size);

 	}

 void free_mem_block(void* block)

 	{

 	PMemMgr::Free(block);

 	}

 }

 /******************************************************************************

  * Task management

  ******************************************************************************/

 TInt PThread::NumTasks;

 TInt PThread::MaxTaskId;

 PThread** PThread::TaskTable;

 // RTOS priority to nanokernel priority mapping

 const TUint8 PThread::NThreadPriorityTable[MAX_TASK_PRIORITY+1] =

 	{

 	0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03,

 	0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07,

 	0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b,

 	0x0c, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0d, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, 0x0f, 0x0f,

 	0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x11, 0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13,

 	0x14, 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, 0x15, 0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17,

 	0x18, 0x18, 0x18, 0x18, 0x19, 0x19, 0x19, 0x19, 0x1a, 0x1a, 0x1a, 0x1a, 0x1b, 0x1b, 0x1b, 0x1b,

 	0x1c, 0x1c, 0x1c, 0x1c, 0x1d, 0x1d, 0x1d, 0x1d, 0x1e, 0x1e, 0x1e, 0x1e, 0x1f, 0x1f, 0x1f, 0x1f,

 	0x20, 0x20, 0x20, 0x20, 0x21, 0x21, 0x21, 0x21, 0x22, 0x22, 0x22, 0x22, 0x23, 0x23, 0x23, 0x23,

 	0x24, 0x24, 0x24, 0x24, 0x25, 0x25, 0x25, 0x25, 0x26, 0x26, 0x26, 0x26, 0x27, 0x27, 0x27, 0x27,

 	0x28, 0x28, 0x28, 0x28, 0x29, 0x29, 0x29, 0x29, 0x2a, 0x2a, 0x2a, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b,

 	0x2c, 0x2c, 0x2c, 0x2c, 0x2d, 0x2d, 0x2d, 0x2d, 0x2e, 0x2e, 0x2e, 0x2e, 0x2f, 0x2f, 0x2f, 0x2f,

 	0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x31, 0x31, 0x32, 0x32, 0x32, 0x32, 0x33, 0x33, 0x33, 0x33,

 	0x34, 0x34, 0x34, 0x34, 0x35, 0x35, 0x35, 0x35, 0x36, 0x36, 0x36, 0x36, 0x37, 0x37, 0x37, 0x37,

 	0x38, 0x38, 0x38, 0x38, 0x39, 0x39, 0x39, 0x39, 0x3a, 0x3a, 0x3a, 0x3a, 0x3b, 0x3b, 0x3b, 0x3b,

 	0x3c, 0x3c, 0x3c, 0x3c, 0x3d, 0x3d, 0x3d, 0x3d, 0x3e, 0x3e, 0x3e, 0x3e, 0x3f, 0x3f, 0x3f, 0x3f

 	};

 // Handlers for personality layer threads

 const SNThreadHandlers PThread::Handlers =

 	{

 	NULL,				// no exit handler

 	&StateHandler,

 	&ExceptionHandler,

 	NULL				// no timeout handler

 	};

 // Create a personality layer thread

 TInt PThread::Create(PThread*& aThread, const taskinfo* a)

 	{

 	if (!a->entry_pt)

 		return BAD_ENTRY_POINT;

 	if (a->priority < MIN_TASK_PRIORITY || a->priority > MAX_TASK_PRIORITY)

 		return BAD_PRIORITY;

 	if (a->stack_size & 3 || a->stack_size < MIN_STACK_SIZE)

 		return BAD_STACK_SIZE;

 	if (a->task_id < 0)

 		return BAD_TASK_ID;

 	TInt memsize = sizeof(PThread) + a->stack_size;

 	PThread* t = (PThread*)Kern::Alloc(memsize);

 	if (!t)

 		return OUT_OF_MEMORY;

 	t->iTaskId = a->task_id;

 	t->iSetPriority = a->priority;

 	t->iFirstMsg = NULL;

 	t->iLastMsg = NULL;

 	t->iISRFirstMsg = NULL;

 	t->iISRLastMsg = NULL;

 	new (&t->iMsgQIDfc) TDfc(&MsgQIDfcFn, t);

 	TAny* stack = t + 1;

 	memset(stack, 0xbb, a->stack_size);

 	SNThreadCreateInfo info;

 	info.iFunction = (NThreadFunction)a->entry_pt;

 	info.iStackBase = stack;

 	info.iStackSize = a->stack_size;

 	info.iPriority = NThreadPriorityTable[a->priority];

 	info.iTimeslice = -1;	// no timeslicing

 	info.iAttributes = 0;

 	info.iHandlers = &Handlers;

 	info.iFastExecTable = NULL;

 	info.iSlowExecTable = NULL;

 	info.iParameterBlock = NULL;

 	info.iParameterBlockSize = 0;

 	TInt r = NKern::ThreadCreate(t, info);

 	__NK_ASSERT_ALWAYS(r==KErrNone);

 	aThread = t;

 	return OK;

 	}

 // Create all required personality layer threads

 void PThread::CreateAll(const taskinfo* a)

 	{

 	TInt n = 0;

 	TInt maxid = -1;

 	for (; a[n].entry_pt; ++n)

 		{

 		if (a[n].task_id > maxid)

 			maxid = a[n].task_id;

 		}

 	NumTasks = n;

 	MaxTaskId = maxid;

 	TaskTable = (PThread**)Kern::AllocZ((maxid+1) * sizeof(PThread*));

 	__NK_ASSERT_ALWAYS(TaskTable != NULL);

 	TInt i;

 	for (i=0; i<NumTasks; ++i)

 		{

 		TInt r = Create(TaskTable[a[i].task_id], a+i);

 		__NK_ASSERT_ALWAYS(r == KErrNone);

 		}

 	// resume the tasks

 	for (i=0; i<NumTasks; ++i)

 		{

 		if (a[i].auto_start)

 			NKern::ThreadResume(TaskTable[i]);

 		}

 	}

 // State handler

 void PThread::StateHandler(NThread* aThread, TInt aOp, TInt aParam)

 	{

 	PThread* t = (PThread*)aThread;

 	switch (aOp)

 		{

 		case NThreadBase::ESuspend:

 			t->HandleSuspend();

 			break;

 		case NThreadBase::EResume:

 		case NThreadBase::EForceResume:

 			t->HandleResume();

 			break;

 		case NThreadBase::ERelease:

 			t->HandleRelease(aParam);

 			break;

 		case NThreadBase::EChangePriority:

 			t->HandlePriorityChange(aParam);

 			break;

 		case NThreadBase::ETimeout:

 			t->HandleTimeout();

 			break;

 		case NThreadBase::ELeaveCS:

 		default:

 			__NK_ASSERT_ALWAYS(0);

 		}

 	}

 // Exception handler - just fault

 void PThread::ExceptionHandler(TAny* aContext, NThread* aThread)

 	{

 	(void)aThread;

 	Exc::Fault(aContext);

 	}

 // Post a message to this thread from an ISR

 void PThread::ISRPost(msghdr* aM)

 	{

 	aM->next = NULL;

 	aM->sending_task_id = TASK_ID_ISR;

 	msghdr* prev = (msghdr*)__e32_atomic_swp_ord_ptr(&iISRLastMsg, aM);

 	if (prev)

 		prev->next = aM;

 	else

 		{

 		iISRFirstMsg = aM;

 		iMsgQIDfc.Add();

 		}

 	}

 // IDFC used to post message from ISR

 void PThread::MsgQIDfcFn(TAny* aPtr)

 	{

 	PThread* t = (PThread*)aPtr;

 	TInt irq = NKern::DisableAllInterrupts();

 	msghdr* m = t->iISRFirstMsg;

 	msghdr* l = t->iISRLastMsg;

 	t->iISRFirstMsg = NULL;

 	t->iISRLastMsg = NULL;

 	NKern::RestoreInterrupts(irq);

 	t->Post(m, l);

 	}

 // Post a chain of messages to this thread from an IDFC or thread

 // Enter and return with preemption disabled

 void PThread::Post(msghdr* aFirst, msghdr* aLast)

 	{

 	msghdr* l = iLastMsg;

 	iLastMsg = aLast;

 	if (l)

 		{

 		l->next = aFirst;

 		return;	// queue was not empty so thread can't be waiting

 		}

 	iFirstMsg = aFirst;

 	if (iNState == EWaitMsgQ)

 		Release(KErrNone);

 	}

 // Dequeue and return the first message if there is one

 // Return NULL if no messages waiting

 // Enter and return with preemption disabled

 msghdr* PThread::GetMsg()

 	{

 	msghdr* m = iFirstMsg;

 	if (m)

 		{

 		iFirstMsg = m->next;

 		if (!iFirstMsg)

 			iLastMsg = NULL;

 		}

 	return m;

 	}

 void PThread::HandleSuspend()

 	{

 	switch(iNState)

 		{

 		case EWaitMsgQ:

 			break;

 		case EWaitSemaphore:

 			((PSemaphore*)iWaitObj)->SuspendWaitingThread(this);

 			break;

 		default:

 			__NK_ASSERT_ALWAYS(0);

 		}

 	}

 void PThread::HandleResume()

 	{

 	switch(iNState)

 		{

 		case EWaitMsgQ:

 			break;

 		case EWaitSemaphore:

 			((PSemaphore*)iWaitObj)->ResumeWaitingThread(this);

 			break;

 		default:

 			__NK_ASSERT_ALWAYS(0);

 		}

 	}

 void PThread::HandleRelease(TInt aReturnCode)

 	{

 	(void)aReturnCode;

 	switch(iNState)

 		{

 		case EWaitMsgQ:

 			CheckSuspendThenReady();

 			break;

 		case EWaitSemaphore:

 			if (aReturnCode<0)

 				((PSemaphore*)iWaitObj)->WaitCancel(this);

 			else

 				CheckSuspendThenReady();

 			break;

 		default:

 			__NK_ASSERT_ALWAYS(0);

 		}

 	}

 void PThread::HandlePriorityChange(TInt aNewPriority)

 	{

 	(void)aNewPriority;

 	switch(iNState)

 		{

 		case EWaitMsgQ:

 			iPriority = (TUint8)aNewPriority;

 			break;

 		case EWaitSemaphore:

 			((PSemaphore*)iWaitObj)->ChangeWaitingThreadPriority(this, aNewPriority);

 			break;

 		default:

 			__NK_ASSERT_ALWAYS(0);

 		}

 	}

 void PThread::HandleTimeout()

 	{

 	switch(iNState)

 		{

 		case EWaitMsgQ:

 			CheckSuspendThenReady();

 			break;

 		case EWaitSemaphore:

 			((PSemaphore*)iWaitObj)->WaitCancel(this);

 			break;

 		default:

 			__NK_ASSERT_ALWAYS(0);

 		}

 	}

 /* Task APIs */

 extern "C" {

 int suspend_task(int id)

 	{

 	if (TUint(id) > TUint(PThread::MaxTaskId))

 		return BAD_TASK_ID;

 	PThread* t = PThread::TaskTable[id];

 	if (!t)

 		return BAD_TASK_ID;

 	NKern::ThreadSuspend(t, 1);

 	return OK;

 	}

 int resume_task(int id)

 	{

 	if (TUint(id) > TUint(PThread::MaxTaskId))

 		return BAD_TASK_ID;

 	PThread* t = PThread::TaskTable[id];

 	if (!t)

 		return BAD_TASK_ID;

 	NKern::ThreadResume(t);

 	return OK;

 	}

 int get_task_priority(int id)

 	{

 	if (TUint(id) > TUint(PThread::MaxTaskId))

 		return BAD_TASK_ID;

 	PThread* t = PThread::TaskTable[id];

 	if (!t)

 		return BAD_TASK_ID;

 	return t->iSetPriority;

 	}

 int set_task_priority(int id, int priority)

 	{

 	if (TUint(id) > TUint(PThread::MaxTaskId))

 		return BAD_TASK_ID;

 	PThread* t = PThread::TaskTable[id];

 	if (!t)

 		return BAD_TASK_ID;

 	if (priority < MIN_TASK_PRIORITY || priority > MAX_TASK_PRIORITY)

 		return BAD_PRIORITY;

 	NKern::Lock();

 	t->iSetPriority = priority;

 	t->SetPriority(PThread::NThreadPriorityTable[priority]);

 	NKern::Unlock();

 	return OK;

 	}

 int current_task_id(void)

 	{

 	TInt c = NKern::CurrentContext();

 	if (c == NKern::EInterrupt)

 		return TASK_ID_ISR;

 	PThread* t = (PThread*)NKern::CurrentThread();

 	if (t->iHandlers == &PThread::Handlers)

 		return t->iTaskId;

 	return TASK_ID_UNKNOWN;

 	}

 void disable_preemption(void)

 	{

 	NKern::Lock();

 	}

 void enable_preemption(void)

 	{

 	NKern::Unlock();

 	}

 int disable_interrupts(void)

 	{

 	return NKern::DisableAllInterrupts();

 	}

 void restore_interrupts(int level)

 	{

 	NKern::RestoreInterrupts(level);

 	}

 /* Message APIs */

 int send_msg(int task_id, msghdr* msg)

 	{

 	if (TUint(task_id) > TUint(PThread::MaxTaskId))

 		return BAD_TASK_ID;

 	PThread* t = PThread::TaskTable[task_id];

 	if (!t)

 		return BAD_TASK_ID;

 	TInt c = NKern::CurrentContext();

 	if (c == NKern::EInterrupt)

 		{

 		t->ISRPost(msg);

 		return OK;

 		}

 	msg->next = NULL;

 	PThread* st = (PThread*)NKern::CurrentThread();

 	msg->sending_task_id = (st->iHandlers == &PThread::Handlers) ? st->iTaskId : TASK_ID_UNKNOWN;

 	NKern::Lock();

 	t->Post(msg, msg);

 	NKern::Unlock();

 	return OK;

 	}

 int recv_msg(msghdr** msgptr, int time_ticks)

 	{

 	if (time_ticks < WAIT_FOREVER)

 		return BAD_TIME_INTERVAL;

 	PThread* t = (PThread*)NKern::CurrentThread();

 	NKern::Lock();

 	msghdr* m = t->GetMsg();

 	if (!m && time_ticks != NO_WAIT)

 		{

 		NKern::NanoBlock(time_ticks>0 ? time_ticks : 0, PThread::EWaitMsgQ, NULL);

 		NKern::PreemptionPoint();

 		m = t->GetMsg();

 		}

 	NKern::Unlock();

 	*msgptr = m;

 	return m ? OK : TIMED_OUT;

 	}

 }

 /******************************************************************************

  * Timer management

  ******************************************************************************/

 TInt PTimer::NumTimers;

 PTimer* PTimer::TimerTable;

 // Create all required timers

 void PTimer::CreateAll()

 	{

 	NumTimers = timer_count;

 	TimerTable = new PTimer[timer_count];

 	__NK_ASSERT_ALWAYS(TimerTable != NULL);

 	}

 PTimer::PTimer()

 	:	NTimer(NTimerExpired, this),

 		iPeriod(0),

 		iCookie(0),

 		iThread(0),

 		iExpiryCount(0)

 	{

 	}

 void PTimer::NTimerExpired(TAny* aPtr)

 	{

 	timer_msg* m = (timer_msg*)alloc_mem_block(sizeof(timer_msg));

 	m->header.next = 0;

 	m->header.msg_id = MSG_ID_TIMEOUT;

 	PTimer* p = (PTimer*)aPtr;

 	TInt irq = NKern::DisableAllInterrupts();

 	PThread* t = p->iThread;

 	m->count = ++p->iExpiryCount;

 	m->cookie = p->iCookie;

 	if (p->iPeriod > 0)

 		p->Again(p->iPeriod);

 	NKern::RestoreInterrupts(irq);

 	t->ISRPost(&m->header);

 	}

 /* Timer APIs */

 extern "C" {

 unsigned tick_count(void)

 	{

 	return NKern::TickCount();

 	}

 void delay(int time_interval)

 	{

 	__NK_ASSERT_ALWAYS(time_interval > 0);

 	NKern::Sleep(time_interval);

 	}

 int start_one_shot_timer(int timer_id, int task_id, int time_ticks, void* cookie)

 	{

 	if (time_ticks <= 0)

 		return BAD_TIME_INTERVAL;

 	if (TUint(timer_id) >= TUint(PTimer::NumTimers))

 		return BAD_TIMER_ID;

 	PTimer* tmr = PTimer::TimerTable + timer_id;

 	if (TUint(task_id) > TUint(PThread::MaxTaskId))

 		return BAD_TASK_ID;

 	PThread* t = PThread::TaskTable[task_id];

 	if (!t)

 		return BAD_TASK_ID;

 	TInt r = OK;

 	TInt irq = NKern::DisableAllInterrupts();

 	if (tmr->iThread)

 		r = TIMER_IN_USE;

 	else

 		{

 		tmr->iPeriod = 0;

 		tmr->iCookie = cookie;

 		tmr->iThread = t;

 		tmr->iExpiryCount = 0;

 		tmr->OneShot(time_ticks, EFalse);

 		}

 	NKern::RestoreInterrupts(irq);

 	return r;

 	}

 int start_periodic_timer(int timer_id, int task_id, int initial_time_ticks, int period_ticks, void* cookie)

 	{

 	if (initial_time_ticks <= 0 || period_ticks <= 0)

 		return BAD_TIME_INTERVAL;

 	if (TUint(timer_id) >= TUint(PTimer::NumTimers))

 		return BAD_TIMER_ID;

 	PTimer* tmr = PTimer::TimerTable + timer_id;

 	if (TUint(task_id) > TUint(PThread::MaxTaskId))

 		return BAD_TASK_ID;

 	PThread* t = PThread::TaskTable[task_id];

 	if (!t)

 		return BAD_TASK_ID;

 	TInt r = OK;

 	TInt irq = NKern::DisableAllInterrupts();

 	if (tmr->iThread)

 		r = TIMER_IN_USE;

 	else

 		{

 		tmr->iPeriod = period_ticks;

 		tmr->iCookie = cookie;

 		tmr->iThread = t;

 		tmr->iExpiryCount = 0;

 		tmr->OneShot(initial_time_ticks, EFalse);

 		}

 	NKern::RestoreInterrupts(irq);

 	return r;

 	}

 int stop_timer(int timer_id)

 	{

 	if (TUint(timer_id) >= TUint(PTimer::NumTimers))

 		return BAD_TIMER_ID;

 	PTimer* tmr = PTimer::TimerTable + timer_id;

 	TInt irq = NKern::DisableAllInterrupts();

 	tmr->Cancel();

 	tmr->iThread = NULL;

 	NKern::RestoreInterrupts(irq);

 	return OK;

 	}

 }

 /******************************************************************************

  * Semaphore management

  ******************************************************************************/

 TInt PSemaphore::NumSemaphores;

 PSemaphore* PSemaphore::SemaphoreTable;

 void PSemaphore::CreateAll()

 	{

 	NumSemaphores = semaphore_count;

 	SemaphoreTable = new PSemaphore[semaphore_count];

 	__NK_ASSERT_ALWAYS(SemaphoreTable != NULL);

 	}

 PSemaphore::PSemaphore()

 	:	iCount(0),

 		iISRCount(0),

 		iIDfc(IDfcFn, this)

 	{

 	}

 void PSemaphore::WaitCancel(PThread* aThread)

 	{

 	if (aThread->iSuspendCount == 0)

 		{

 		iWaitQ.Remove(aThread);

 		++iCount;

 		}

 	else

 		aThread->Deque();

 	aThread->CheckSuspendThenReady();

 	}

 void PSemaphore::SuspendWaitingThread(PThread* aThread)

 	{

 	// do nothing if already suspended

 	if (aThread->iSuspendCount == 0)

 		{

 		iWaitQ.Remove(aThread);

 		++iCount;

 		iSuspendedQ.Add(aThread);

 		}

 	}

 void PSemaphore::ResumeWaitingThread(PThread* aThread)

 	{

 	aThread->Deque();

 	if (--iCount<0)

 		{

 		iWaitQ.Add(aThread);

 		}

 	else

 		{

 		aThread->iWaitObj=NULL;

 		aThread->Ready();

 		}

 	}

 void PSemaphore::ChangeWaitingThreadPriority(PThread* aThread, TInt aNewPriority)

 	{

 	if (aThread->iSuspendCount == 0)

 		iWaitQ.ChangePriority(aThread, aNewPriority);

 	else

 		aThread->iPriority = (TUint8)aNewPriority;

 	}

 void PSemaphore::Signal()

 	{

 	if (++iCount <= 0)

 		{

 		// must wake up next thread

 		PThread* t = iWaitQ.First();

 		iWaitQ.Remove(t);

 		t->Release(KErrNone);

 		}

 	}

 void PSemaphore::ISRSignal()

 	{

 	if (__e32_atomic_add_ord32(&iISRCount, 1) == 0)

 		iIDfc.Add();

 	}

 void PSemaphore::IDfcFn(TAny* aPtr)

 	{

 	PSemaphore* s = (PSemaphore*)aPtr;

 	TInt count = (TInt)__e32_atomic_swp_ord32(&s->iISRCount, 0);

 	while (count--)

 		s->Signal();

 	}

 /* Semaphore APIs */

 extern "C" {

 int semaphore_wait(int sem_id, int time_ticks)

 	{

 	if (time_ticks < WAIT_FOREVER)

 		return BAD_TIME_INTERVAL;

 	if (TUint(sem_id) >= TUint(PSemaphore::NumSemaphores))

 		return BAD_SEM_ID;

 	PSemaphore* s = PSemaphore::SemaphoreTable + sem_id;

 	PThread* t = (PThread*)NKern::CurrentThread();

 	TInt r = OK;

 	NKern::Lock();

 	if (time_ticks == NO_WAIT)

 		{

 		if (s->iCount <= 0)

 			r = TIMED_OUT;

 		else

 			--s->iCount;

 		NKern::Unlock();

 		return r;

 		}

 	if (--s->iCount < 0)

 		{

 		NKern::NanoBlock(time_ticks>0 ? time_ticks : 0, PThread::EWaitSemaphore, s);

 		s->iWaitQ.Add(t);

 		NKern::PreemptionPoint();

 		if (t->iReturnValue == KErrTimedOut)

 			r = TIMED_OUT;

 		}

 	NKern::Unlock();

 	return r;

 	}

 int semaphore_signal(int sem_id)

 	{

 	if (TUint(sem_id) >= TUint(PSemaphore::NumSemaphores))

 		return BAD_SEM_ID;

 	PSemaphore* s = PSemaphore::SemaphoreTable + sem_id;

 	TInt c = NKern::CurrentContext();

 	if (c == NKern::EInterrupt)

 		{

 		s->ISRSignal();

 		return OK;

 		}

 	NKern::Lock();

 	s->Signal();

 	NKern::Unlock();

 	return OK;

 	}

 void init_personality(void)

 	{

 	__KTRACE_OPT(KBOOT,Kern::Printf("Starting example personality"));

 	PMemMgr::Create(pool_list);

 	PTimer::CreateAll();

 	PSemaphore::CreateAll();

 	PThread::CreateAll(task_list);

 	}

 }

 /******************************************************************************

  * Communication with EPOC

  ******************************************************************************/

 TPMsgQ* TPMsgQ::ThePMsgQ;

 TPMsgQ::TPMsgQ(TDfcFn aFunction, TAny* aPtr, TDfcQue* aDfcQ, TInt aPriority)

 	:	TDfc(aFunction, aPtr, aDfcQ, aPriority),

 		iFirstMsg(NULL),

 		iLastMsg(NULL),

 		iReady(EFalse)

 	{

 	}

 extern "C" void send_to_epoc(msghdr* m)

 	{

 	TPMsgQ* q = TPMsgQ::ThePMsgQ;

 	m->next = NULL;

 	m->sending_task_id = current_task_id();

 	NKern::Lock();

 	msghdr* l = q->iLastMsg;

 	q->iLastMsg = m;

 	if (l)

 		{

 		l->next = m;

 		NKern::Unlock();

 		return;	// queue was not empty so thread can't be waiting

 		}

 	q->iFirstMsg = m;

 	if (q->iReady)

 		{

 		q->iReady = EFalse;

 		q->DoEnque();

 		}

 	NKern::Unlock();

 	}

 void TPMsgQ::Receive()

 	{

 	NKern::Lock();

 	if (iFirstMsg)

 		DoEnque();

 	else

 		iReady = ETrue;

 	NKern::Unlock();

 	}

 msghdr* TPMsgQ::Get()

 	{

 	NKern::Lock();

 	msghdr* m = iFirstMsg;

 	if (m)

 		{

 		iFirstMsg = m->next;

 		if (!iFirstMsg)

 			iLastMsg = NULL;

 		}

 	NKern::Unlock();

 	return m;

 	}

 void TPMsgQ::CancelReceive()

 	{

 	iReady = EFalse;

 	Cancel();

 	}