sys_arch.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <kernel.h>
#include <time.h>
#include <limits.h>
#include "lwip/sys.h"
#include "lwip/opt.h"
#include "lwip/stats.h"
#include "lwip/debug.h"
#include "lwip/pbuf.h"
#include "arch/sys_arch.h"
#include "ps2ip_internal.h"

Include dependency graph for sys_arch.c:

Go to the source code of this file.

Functions
static arch_message *	alloc_msg (void)
static void	free_msg (arch_message *msg)
static int	WaitSemaTimeout (int sema, unsigned int msec)
static arch_message *	try_alloc_msg (void)
static void	TimeoutHandler (s32 alarm_id, u16 time, void *pvArg)
static u32_t	ComputeTimeDiff (u32 start, u32 end)
sys_thread_t	sys_thread_new (const char *name, lwip_thread_fn thread, void *arg, int stacksize, int prio)
err_t	sys_mbox_new (sys_mbox_t *mbox, int size)
void	sys_mbox_free (sys_mbox_t *pMBox)
int	sys_mbox_valid (sys_mbox_t *mbox)
void	sys_mbox_set_invalid (sys_mbox_t *mbox)
static unsigned int	mSec2HSyncTicks (unsigned int msec)
static void	RetrieveMbxInternal (sys_mbox_t mBox, arch_message **message)
static int	ReceiveMbx (arch_message **message, sys_mbox_t mBox, u32_t timeout)
static int	PollMbx (arch_message **message, sys_mbox_t mBox)
static u32_t	sys_arch_mbox_fetch_internal (sys_mbox_t pMBox, void **ppvMSG, u32_t u32Timeout, char block)
u32_t	sys_arch_mbox_fetch (sys_mbox_t *pMBox, void **ppvMSG, u32_t u32Timeout)
u32_t	sys_arch_mbox_tryfetch (sys_mbox_t *pMBox, void **ppvMSG)
static void	SendMbx (sys_mbox_t *mbox, arch_message *msg, void *sys_msg)
err_t	sys_mbox_trypost (sys_mbox_t *mbox, void *sys_msg)
void	sys_mbox_post (sys_mbox_t *mbox, void *sys_msg)
err_t	sys_sem_new (sys_sem_t *sem, u8_t count)
u32_t	sys_arch_sem_wait (sys_sem_t *sema, u32_t timeout)
void	sys_sem_signal (sys_sem_t *Sema)
void	sys_sem_free (sys_sem_t *Sema)
int	sys_sem_valid (sys_sem_t *sem)
void	sys_sem_set_invalid (sys_sem_t *sem)
void	sys_init (void)
u32_t	sys_now (void)
sys_prot_t	sys_arch_protect (void)
void	sys_arch_unprotect (sys_prot_t level)
void *	ps2ip_calloc64 (size_t n, size_t size)

Variables
static arch_message	msg_pool [SYS_MAX_MESSAGES]
static arch_message *	free_head
static int	MsgCountSema
void *	_gp
unsigned short int	hsyncTicksPerMSec

Function Documentation

alloc_msg()

static arch_message * alloc_msg ( void  )

inlinestatic

Definition at line 56 of file sys_arch.c.

{
        arch_message *message;
 
        WaitSema(MsgCountSema);
        DI();
 
        message = free_head;
        free_head = free_head->next;
 
        EI();
 
        return message;
}

References DI, EI, free_head, MsgCountSema, arch_message::next, and WaitSema().

Referenced by sys_mbox_post().

ComputeTimeDiff()

static u32_t ComputeTimeDiff ( u32  start, u32  end  )

inlinestatic

Definition at line 87 of file sys_arch.c.

{
        u32 NumTicksElasped=(end<start)?UINT_MAX-start+end:start-end;
 
        return(NumTicksElasped/295000);
}

Referenced by sys_arch_mbox_fetch_internal(), and sys_arch_sem_wait().

free_msg()

static void free_msg ( arch_message *  msg )

static

Definition at line 71 of file sys_arch.c.

{
        DI();
 
        msg->next = free_head;
        free_head = msg;
 
        EI();
        SignalSema(MsgCountSema);
}

References DI, EI, free_head, MsgCountSema, arch_message::next, and SignalSema().

Referenced by sys_arch_mbox_fetch_internal(), and sys_mbox_free().

mSec2HSyncTicks()

static unsigned int mSec2HSyncTicks ( unsigned int  msec )

inlinestatic

Definition at line 193 of file sys_arch.c.

{
        return msec*hsyncTicksPerMSec;
}

References hsyncTicksPerMSec.

Referenced by WaitSemaTimeout().

PollMbx()

static int PollMbx ( arch_message **  message, sys_mbox_t  mBox  )

static

Definition at line 263 of file sys_arch.c.

{
        int result;
 
        if(PollSema(mBox->MessageCountSema)==mBox->MessageCountSema)
        {
                RetrieveMbxInternal(mBox, message);
                result=0;
        }
        else result=-1;
 
        return result;
}

References PollSema(), result, and RetrieveMbxInternal().

Referenced by sys_arch_mbox_fetch_internal().

ps2ip_calloc64()

void* ps2ip_calloc64	(	size_t	n,
		size_t	size
	)

Definition at line 466 of file sys_arch.c.

{
        void *ptr = NULL;
        size_t sz = n * size;
 
        if ((ptr = memalign(64, sz)) == NULL)
                return ptr;
 
        memset(ptr, 0, sz);
        return ptr;
}

References NULL.

ReceiveMbx()

static int ReceiveMbx ( arch_message **  message, sys_mbox_t  mBox, u32_t  timeout  )

static

Definition at line 243 of file sys_arch.c.

{
        int result;
 
        if(timeout > 0) {
                result = WaitSemaTimeout(mBox->MessageCountSema, timeout);
        } else {
                result = WaitSema(mBox->MessageCountSema);
        }
 
        if(result == mBox->MessageCountSema)
        {
                RetrieveMbxInternal(mBox, message);
                result=0;
        }
        else result=-1;
 
        return result;
}

References result, RetrieveMbxInternal(), WaitSema(), and WaitSemaTimeout().

Referenced by sys_arch_mbox_fetch_internal().

RetrieveMbxInternal()

static void RetrieveMbxInternal ( sys_mbox_t  mBox, arch_message **  message  )

static

Definition at line 198 of file sys_arch.c.

{
        arch_message *NextMessage;
 
        DI();
 
        *message=mBox->FirstMessage;    //Take first message in mbox
 
        //The next message is next. If there is no next message, NULL is assigned,
        NextMessage=(unsigned int)(*message)->next!=0xFFFFFFFF?(*message)->next:NULL;
 
        //if the mbox only had one message, then update LastMessage as well.
        if(mBox->FirstMessage == mBox->LastMessage)
                mBox->LastMessage = NULL;
 
        mBox->FirstMessage = NextMessage;       //The next message becomes the first message. Or NULL, if there are no next messages.
 
        EI();
}

References DI, EI, arch_message::next, and NULL.

Referenced by PollMbx(), and ReceiveMbx().

SendMbx()

static void SendMbx ( sys_mbox_t *  mbox, arch_message *  msg, void *  sys_msg  )

static

Definition at line 317 of file sys_arch.c.

                                                                       {
        DI();
 
        /* Store the message and update the message chain for this message box. */
        msg->sys_msg = sys_msg;
        msg->next = NULL;
        if((*mbox)->FirstMessage==NULL) (*mbox)->FirstMessage=msg;      //If this is the first message, it goes at the front.
        if((*mbox)->LastMessage!=NULL) (*mbox)->LastMessage->next=msg;  //Otherwise, it becomes the next message of the last message.
        (*mbox)->LastMessage=msg;                                       //The message becomes the new message at the end of the queue.
 
        EI();
        SignalSema((*mbox)->MessageCountSema);
}

References DI, EI, arch_message::next, NULL, SignalSema(), and arch_message::sys_msg.

Referenced by sys_mbox_post(), and sys_mbox_trypost().

sys_arch_mbox_fetch()

u32_t sys_arch_mbox_fetch	(	sys_mbox_t *	pMBox,
		void **	ppvMSG,
		u32_t	u32Timeout
	)

Definition at line 307 of file sys_arch.c.

{
        return sys_arch_mbox_fetch_internal(*pMBox, ppvMSG, u32Timeout, 1);
}

References sys_arch_mbox_fetch_internal().

sys_arch_mbox_fetch_internal()

static u32_t sys_arch_mbox_fetch_internal ( sys_mbox_t  pMBox, void **  ppvMSG, u32_t  u32Timeout, char  block  )

static

Definition at line 277 of file sys_arch.c.

{
        arch_message *pmsg;
        unsigned int TimeElasped, start;
        int result;
 
        TimeElasped=0;
        if(block){
                start=clock()/(CLOCKS_PER_SEC/1000);
 
                if((result=ReceiveMbx(&pmsg, pMBox, u32Timeout))==0){
                        TimeElasped = ComputeTimeDiff(start, clock()/(CLOCKS_PER_SEC/1000));
                }
                else{
                        return SYS_ARCH_TIMEOUT;
                }
        }
        else{
                TimeElasped=((result=PollMbx(&pmsg, pMBox))!=0)?SYS_MBOX_EMPTY:0;
        }
 
        if(result==0){
                if(ppvMSG!=NULL) *ppvMSG = pmsg->sys_msg;
                free_msg(pmsg);
        }
 
        //Return the number of msec waited.
        return TimeElasped;
}

References ComputeTimeDiff(), free_msg(), NULL, PollMbx(), ReceiveMbx(), result, and arch_message::sys_msg.

Referenced by sys_arch_mbox_fetch(), and sys_arch_mbox_tryfetch().

sys_arch_mbox_tryfetch()

u32_t sys_arch_mbox_tryfetch	(	sys_mbox_t *	pMBox,
		void **	ppvMSG
	)

Definition at line 312 of file sys_arch.c.

{
        return sys_arch_mbox_fetch_internal(*pMBox, ppvMSG, 0, 0);
}

References sys_arch_mbox_fetch_internal().

sys_arch_protect()

sys_prot_t sys_arch_protect

(

void

)

Definition at line 455 of file sys_arch.c.

{
        return DIntr();
}

References DIntr().

sys_arch_sem_wait()

u32_t sys_arch_sem_wait	(	sys_sem_t *	sema,
		u32_t	timeout
	)

Definition at line 373 of file sys_arch.c.

{
        u32_t result;
 
        //Wait timeout msec for the Sema to receive a signal.
        if(timeout==0)
        {
                //Wait with no timeouts.
                result=(WaitSema(*sema)==*sema?0:SYS_ARCH_TIMEOUT);
        }
        else if(timeout==1)
        {
                //Poll.
                result=(PollSema(*sema)==*sema?0:SYS_ARCH_TIMEOUT);
        }
        else
        {
                //Use alarm to timeout.
                unsigned int start;
                u32_t   WaitTime;
 
                start=clock()/(CLOCKS_PER_SEC/1000);
                if(WaitSemaTimeout(*sema, timeout) == *sema)
                {
                        WaitTime=ComputeTimeDiff(start, clock()/(CLOCKS_PER_SEC/1000));
                        result=(WaitTime <= timeout ? WaitTime : timeout);
                }
                else result=SYS_ARCH_TIMEOUT;
        }
 
        return result;
}

References ComputeTimeDiff(), PollSema(), result, WaitSema(), and WaitSemaTimeout().

Referenced by InitializeLWIP().

sys_arch_unprotect()

void sys_arch_unprotect

(

sys_prot_t

level

)

Definition at line 460 of file sys_arch.c.

{
        if(level)
                EIntr();
}

References EIntr().

sys_init()

void sys_init

(

void

)

Definition at line 424 of file sys_arch.c.

{
        arch_message *prev;
        unsigned int i;
        ee_sema_t sema;
 
        dbgprintf("sys_init: Initializing...\n");
 
        sema.attr = 0;
        sema.option = (u32)"PS2IP";
        sema.init_count = sema.max_count = SYS_MAX_MESSAGES;
        MsgCountSema=CreateSema(&sema);
 
        free_head = &msg_pool[0];
        prev = &msg_pool[0];
 
        for(i = 1; i < SYS_MAX_MESSAGES; i++)
        {
                prev->next = &msg_pool[i];
                prev = &msg_pool[i];
        }
 
        //NULL-terminate free message list
        prev->next = NULL;
}

References ee_sema_t::attr, CreateSema(), dbgprintf, free_head, ee_sema_t::init_count, ee_sema_t::max_count, msg_pool, MsgCountSema, arch_message::next, NULL, ee_sema_t::option, and SYS_MAX_MESSAGES.

sys_mbox_free()

void sys_mbox_free

(

sys_mbox_t *

pMBox

)

Definition at line 162 of file sys_arch.c.

{
        arch_message *Message, *NextMessage;
 
        /* Free all messages that were not freed yet. */
        Message=(*pMBox)->FirstMessage;
        while(Message!=NULL)
        {
                NextMessage=Message->next;
                free_msg(Message);
                Message=NextMessage;
        }
 
        /* Delete all allocated resources for this message box and mark the message box as invalid. */
        DeleteSema((*pMBox)->MessageCountSema);
        free((*pMBox));
        (*pMBox)=SYS_MBOX_NULL;
}

References DeleteSema(), free_msg(), arch_message::next, NULL, and SYS_MBOX_NULL.

sys_mbox_new()

err_t sys_mbox_new	(	sys_mbox_t *	mbox,
		int	size
	)

Definition at line 126 of file sys_arch.c.

{
        struct MboxData *MBox;
        ee_sema_t sema;
 
        *mbox=SYS_MBOX_NULL;
 
        if((MBox=malloc(sizeof(struct MboxData)))!=NULL)
        {
                //Last = first, empty mbox.
                MBox->LastMessage=MBox->FirstMessage=NULL;
 
                sema.attr = 0;
                sema.option = (u32)"PS2IP-msgcount";
                sema.init_count=0;
                sema.max_count=SYS_MAX_MESSAGES;
                if((MBox->MessageCountSema=CreateSema(&sema))<0)
                {
                        printf("sys_mbox_new: CreateMbx failed. Code: %d\n", MBox->MessageCountSema);
                        free(MBox);
                        return ERR_MEM;
                }
        }
        else{
                printf("sys_mbox_new: Out of memory.\n");
                return ERR_MEM;
        }
 
        dbgprintf("sys_mbox_new(): sema %d\n", MBox->MessageCountSema);
 
        *mbox=MBox;
 
        return ERR_OK;
}

References ee_sema_t::attr, CreateSema(), dbgprintf, sys_mbox_t::FirstMessage, ee_sema_t::init_count, sys_mbox_t::LastMessage, ee_sema_t::max_count, sys_mbox_t::MessageCountSema, NULL, ee_sema_t::option, SYS_MAX_MESSAGES, and SYS_MBOX_NULL.

sys_mbox_post()

void sys_mbox_post	(	sys_mbox_t *	mbox,
		void *	sys_msg
	)

Definition at line 347 of file sys_arch.c.

{
        SendMbx(mbox, alloc_msg(), sys_msg);
}

References alloc_msg(), and SendMbx().

sys_mbox_set_invalid()

void sys_mbox_set_invalid

(

sys_mbox_t *

mbox

)

Definition at line 186 of file sys_arch.c.

{
        *mbox=SYS_MBOX_NULL;
}

References SYS_MBOX_NULL.

sys_mbox_trypost()

err_t sys_mbox_trypost	(	sys_mbox_t *	mbox,
		void *	sys_msg
	)

Definition at line 331 of file sys_arch.c.

{
        arch_message *msg;
        err_t result;
 
        /* Attempt to allocate one more message. */
        if((msg=try_alloc_msg())!=NULL){
                SendMbx(mbox, msg, sys_msg);
 
                result=ERR_OK;
        }
        else result=ERR_MEM;
 
        return result;
}

References NULL, result, SendMbx(), and try_alloc_msg().

sys_mbox_valid()

int sys_mbox_valid

(

sys_mbox_t *

mbox

)

Definition at line 181 of file sys_arch.c.

{
        return((*mbox)!=SYS_MBOX_NULL);
}

References SYS_MBOX_NULL.

sys_now()

u32_t sys_now

(

void

)

Definition at line 450 of file sys_arch.c.

{
        return(clock()/(CLOCKS_PER_SEC/1000));
}

sys_sem_free()

void sys_sem_free

(

sys_sem_t *

Sema

)

Definition at line 411 of file sys_arch.c.

{
        DeleteSema(*Sema);
}

References DeleteSema().

Referenced by InitializeLWIP().

sys_sem_new()

err_t sys_sem_new	(	sys_sem_t *	sem,
		u8_t	count
	)

Definition at line 352 of file sys_arch.c.

{
        //Create a new semaphore.
        ee_sema_t sema;
 
        sema.init_count = count;
        sema.max_count = 1;
        sema.attr = 0;
        sema.option = (u32)"PS2IP";
 
        if((*sem=CreateSema(&sema))<0)
        {
                printf("sys_sem_new: CreateSema failed, EC: %d\n", *sem);
                return ERR_MEM;
        }
 
        dbgprintf("sys_sem_new: CreateSema (CNT: %d) %d\n", count, *sem);
 
        return ERR_OK;
}

References ee_sema_t::attr, CreateSema(), dbgprintf, ee_sema_t::init_count, ee_sema_t::max_count, ee_sema_t::option, and sem.

Referenced by InitializeLWIP().

sys_sem_set_invalid()

void sys_sem_set_invalid

(

sys_sem_t *

sem

)

Definition at line 420 of file sys_arch.c.

                                        {
        *sem=SYS_SEM_NULL;
}

References sem, and SYS_SEM_NULL.

sys_sem_signal()

void sys_sem_signal

(

sys_sem_t *

Sema

)

Definition at line 406 of file sys_arch.c.

{
        SignalSema(*Sema);
}

References SignalSema().

Referenced by InitDone().

sys_sem_valid()

int sys_sem_valid

(

sys_sem_t *

sem

)

Definition at line 416 of file sys_arch.c.

                                 {
        return(*sem>=0);
}

References sem.

sys_thread_new()

sys_thread_t sys_thread_new	(	const char *	name,
		lwip_thread_fn	thread,
		void *	arg,
		int	stacksize,
		int	prio
	)

Definition at line 95 of file sys_arch.c.

{
        ee_thread_t thp;
        int tid, rv;
 
        thp.attr = 0;
        thp.option = 0;
        thp.func = thread;
        thp.stack_size = stacksize;
        thp.stack = malloc(stacksize);
        thp.initial_priority = prio;
        thp.gp_reg = &_gp;
 
        if((tid = CreateThread(&thp)) < 0)
        {
                dbgprintf("sys_thread_new: CreateThread failed, EC: %d\n", tid);
                return ERR_MEM;
        }
 
        if((rv = StartThread(tid, arg)) < 0)
        {
                dbgprintf("sys_thread_new: StartThread failed, EC: %d\n", rv);
                DeleteThread(tid);
                return ERR_MEM;
        }
 
        dbgprintf("sys_thread_new(): %d\n", tid);
 
        return((sys_thread_t)tid);
}

References _gp, ee_thread_t::attr, CreateThread(), dbgprintf, DeleteThread(), ee_thread_t::func, ee_thread_t::gp_reg, ee_thread_t::initial_priority, ee_thread_t::option, ee_thread_t::stack, ee_thread_t::stack_size, and StartThread().

TimeoutHandler()

static void TimeoutHandler ( s32  alarm_id, u16  time, void *  pvArg  )

static

Definition at line 82 of file sys_arch.c.

                                                               {
        iReleaseWaitThread((int)pvArg);
        ExitHandler();
}

References ExitHandler, and iReleaseWaitThread().

Referenced by WaitSemaTimeout().

try_alloc_msg()

static arch_message* try_alloc_msg ( void  )

inlinestatic

Definition at line 39 of file sys_arch.c.

{
        arch_message *message;
 
        if(PollSema(MsgCountSema)==MsgCountSema)
        {
                DI();
 
                message = free_head;
                free_head = free_head->next;
 
                EI();
        }else message=NULL;
 
        return message;
}

References DI, EI, free_head, MsgCountSema, arch_message::next, NULL, and PollSema().

Referenced by sys_mbox_trypost().

WaitSemaTimeout()

static int WaitSemaTimeout ( int  sema, unsigned int  msec  )

static

Definition at line 218 of file sys_arch.c.

{
        unsigned int ticks;
        unsigned short int ticksToWait;
        int alarmID, threadID;
 
        ticks = mSec2HSyncTicks(msec);
        threadID = GetThreadId();
        while(ticks > 0)
        {
                ticksToWait = ticks > USHRT_MAX ? USHRT_MAX : ticks;
                alarmID = SetAlarm(ticksToWait, &TimeoutHandler, (void*)threadID);
                if (WaitSema(sema) == sema)
                {
                        ReleaseAlarm(alarmID);
                        return sema; //Wait condition satisfied.
                }
 
                //Otherwise, continue waiting.
                ticks -= ticksToWait;
        }
 
        return -1; //Timed out.
}

References GetThreadId(), mSec2HSyncTicks(), ReleaseAlarm(), SetAlarm(), TimeoutHandler(), and WaitSema().

Referenced by ReceiveMbx(), and sys_arch_sem_wait().

Variable Documentation

_gp

void* _gp

extern

Referenced by sys_thread_new().

free_head

arch_message* free_head

static

Definition at line 28 of file sys_arch.c.

Referenced by alloc_msg(), free_msg(), sys_init(), and try_alloc_msg().

hsyncTicksPerMSec

unsigned short int hsyncTicksPerMSec

extern

Definition at line 39 of file ps2ip.c.

Referenced by mSec2HSyncTicks(), and ps2ipSetHsyncTicksPerMSec().

msg_pool

arch_message msg_pool[SYS_MAX_MESSAGES]

static

Definition at line 27 of file sys_arch.c.

Referenced by sys_init().

MsgCountSema

int MsgCountSema

static

Definition at line 35 of file sys_arch.c.

Referenced by alloc_msg(), free_msg(), sys_init(), and try_alloc_msg().