main.c

T-kernel 的extension源代码

/*
 *----------------------------------------------------------------------
 *    T-Kernel / Standard Extension
 *
 *    Copyright (C) 2006 by Ken Sakamura. All rights reserved.
 *    T-Kernel / Standard Extension is distributed 
 *      under the T-License for T-Kernel / Standard Extension.
 *----------------------------------------------------------------------
 *
 *    Version:   1.00.00
 *    Released by T-Engine Forum(http://www.t-engine.org) at 2006/8/11.
 *
 *----------------------------------------------------------------------
 */

/*
 *	main.c (event)
 *
 *	Event management
 *	Initialize/End the manager.
 *	System call / Extended SVC entry
 */

#include "evtmgr.h"
#include <extension/sys/svc/ifevent.h>
#include "others.h"


LOCAL WER emSyscallEntry( VP para, W fn );
LOCAL void emCleanupEntry( ID resid, ID pid );
LOCAL ER initialize( void );
LOCAL ER finish( void );

#define TSD_INE_STK_2048	2048
#define TSD_INE_ARR_300		300

/*
 * Event management common information
 */
EXPORT EmInfo	emInfo;

/* ------------------------------------------------------------------------ */

/*
 * Extended SVC entry
 */
LOCAL WER emSyscallEntry( VP para, W fn )
{
	switch ( fn ) {
	  case EM_GET_EVT_FN: {
		EM_GET_EVT_PARA *p = para;
		return _tkse_get_evt(p->t_mask, p->evt, p->opt);
	  }
	  case EM_PUT_EVT_FN: {
		EM_PUT_EVT_PARA *p = para;
		return _tkse_put_evt(p->evt, p->opt);
	  }
	  case EM_CLR_EVT_FN: {
		EM_CLR_EVT_PARA *p = para;
		return _tkse_clr_evt(p->t_mask, p->last_mask);
	  }
	  case EM_GET_PDP_FN: {
		EM_GET_PDP_PARA *p = para;
		return _tkse_get_pdp(p->pos);
	  }
	  case EM_GET_ETM_FN: {
		EM_GET_ETM_PARA *p = para;
		return _tkse_get_etm(p->time);
	  }
	  case EM_CHG_EMK_FN: {
		EM_CHG_EMK_PARA *p = para;
		return _tkse_chg_emk(p->mask);
	  }
	  case EM_SET_KRP_FN: {
		EM_SET_KRP_PARA *p = para;
		return _tkse_set_krp(p->offset, p->interval);
	  }
	  case EM_GET_KRP_FN: {
		EM_GET_KRP_PARA *p = para;
		return _tkse_get_krp(p->offset, p->interval);
	  }
	  case EM_SET_KRM_FN: {
		EM_SET_KRM_PARA *p = para;
		return _tkse_set_krm(*p->keymap);
	  }
	  case EM_GET_KRM_FN: {
		EM_GET_KRM_PARA *p = para;
		return _tkse_get_krm(*p->keymap);
	  }
	  case EM_REQ_EVT_FN: {
		EM_REQ_EVT_PARA *p = para;
		return _tkse_req_evt(p->t_mask);
	  }
	  case EM_LAS_EVT_FN: {
		EM_LAS_EVT_PARA *p = para;
		return _tkse_las_evt(p->t_mask);
	  }
	  default: {
		/* nothing to do */
		break;
	  }
	}

	return E_RSFN;
}

/*
 * Cleanup service entry.
 */
LOCAL void emCleanupEntry( ID resid, ID pid )
{
	/* Delete the event message request. */
	(void)emRegistEvtMsg(EM_NULL, pid);
}

/* ------------------------------------------------------------------------ */

/*
 * Initialize the manager.
 */
LOCAL ER initialize( void )
{
	/* Clear the event management common information. */
	memset(&emInfo, 0, (size_t)sizeof(emInfo));

	/* Initialize the automatic repeat key.  */
	memset(emInfo.repeatKeymap, 0xff, (size_t)sizeof(KeyMap));

	/* Obtain the system configuration information. */
	{	W	w[L_SYSCONF_VAL];
		W	n;

		/* Obtain the task priority. */
		n = GetSysConf((UB*)"EmTskPri", w);
		if ( n != 1 ) {
			DEBUG_PRINT(("init: get EmTskPri error\n"));
			return E_SYS;
		}
		emInfo.evtRcvTskPri = w[0];

		/* Obtain the event queue size. */
		n = GetSysConf((UB*)"MaxEvtQ", w);
		if ( n != 1 ) {
			DEBUG_PRINT(("init: get MaxEvtQ error\n"));
			return E_SYS;
		}
		emInfo.maxEvtQue = w[0];

		/* Obtain the maximum number of registrations of event message request. */
		n = GetSysConf((UB*)"MaxEvMsg", w);
		if ( n != 1 ) {
			DEBUG_PRINT(("init: get MaxEvMsg error\n"));
			return E_SYS;
		}
		emInfo.maxEvtMsg = w[0];

		/* Obtain the automatic event expiration time. */
		n = GetSysConf((UB*)"EvtLife", w);
		if ( n < 1 ) {
			w[0] = TSD_INE_ARR_300;
		}
		emInfo.evtLifeTime = (UW)w[0];
	}

	/* Obtain the message buffer for device event receiving. */
	emInfo.evtRcvMbf = GetDevEvtMbf();

	/* Create the lock for exclusive access. */
	{	ER	err;

		err = CreateLock(&emInfo.lock, (UB*)"Evt");
		if ( err < E_OK ) {
			DEBUG_PRINT(("init: create lock err = %d\n", err));
			return ERtoERR(err);
		}
	}

	/* Create the event queue. */
	{	ER	err;

		err = emInitEvtQue();
		if ( err < E_OK ) {
			DEBUG_PRINT(("init: InitEvtQue err = %d\n", err));
			return err;
		}
	}

	/* Create the list for registration of event message request. */
	{	EvtMsgEntry	*p;

		p = (EvtMsgEntry *)Kcalloc((size_t)emInfo.maxEvtMsg, sizeof(EvtMsgEntry));
		if ( p == NULL ) {
			DEBUG_PRINT(("init: EvtMsgEntry E_NOMEM"));
			return E_NOMEM;
		}
		emInfo.evtMsgEntry = p;
	}

	/* Generate/Start the event receiving task. */
	{	ID	tskid;
		T_CTSK	ctsk;
		ER	er;

		SetOBJNAME(ctsk.exinf, "Evt");
		ctsk.task    = emEventReceiveTask;
		ctsk.itskpri = emInfo.evtRcvTskPri;
		ctsk.stksz   = TSD_INE_STK_2048;
		ctsk.tskatr  = TA_HLNG|TA_RNG0;
		er = tk_cre_tsk(&ctsk);
		if ( er < E_OK ) {
			DEBUG_PRINT(("init: tk_cre_tsk er = %d\n", er));
			return ERtoERR(er);
		}
		tskid = (ID)er;

		er = tk_sta_tsk(tskid, 0);
		if ( er < E_OK ) {
			(void)tk_del_tsk(tskid);

			DEBUG_PRINT(("init: tk_sta_tsk er = %d\n", er));
			return ERtoERR(er);
		}
		emInfo.evtRcvTskID = tskid;
	}

	/* Register the manager. */
	{	T_DSSY	dssy;
		ER	err;

		dssy.ssyatr    = TA_NULL;
		dssy.ssypri    = EM_PRI;
		dssy.svchdr    = (FP)emSyscallEntry;
		dssy.breakfn   = NULL;
		dssy.startupfn = NULL;
		dssy.cleanupfn = emCleanupEntry;
		dssy.eventfn   = NULL;
		dssy.resblksz  = 0;
		err = tk_def_ssy(EM_SVC, &dssy);
		if ( err < E_OK ) {
			DEBUG_PRINT(("init: DefManager err = %d\n", err));
			return ERtoERR(err);
		}
	}

	return E_OK;
}

/*
 * Terminate the manager.
 */
LOCAL ER finish( void )
{
	ER	error = E_OK;

	/* Deregister the manager. */
	{	ER	err;

		err = tk_def_ssy(EM_SVC, NULL);
		if ( err < E_OK ) {
			DEBUG_PRINT(("finish: DefManager err = %d\n", err));
			error = ERtoERR(err);
		}
	}

	/* Delete the device event receiving task. */
	if ( emInfo.evtRcvTskID != InvalidID ) {
		ER	er;

		er = tk_ter_tsk(emInfo.evtRcvTskID);
		if ( er < E_OK ) {
			DEBUG_PRINT(("finish: tk_ter_tsk er = %d\n", er));
			error = ERtoERR(er);
		}

		er = tk_del_tsk(emInfo.evtRcvTskID);
		if ( er < E_OK ) {
			DEBUG_PRINT(("finish: tk_del_tsk er = %d\n", er));
			error = ERtoERR(er);
		}
	}

	/* Delete the list for registration of event message request. */
	if ( emInfo.evtMsgEntry != NULL ) {
		Kfree(emInfo.evtMsgEntry);
	}

	/* Delete the event queue. */
	{	ER	err;

		err = emDeleteEvtQue();
		if ( err < E_OK ) {
			DEBUG_PRINT(("finish: DeleteEvtQue err = %d\n", err));
			error = err;
		}
	}

	/* Delete the lock for exclusive access. */
	DeleteLock(&emInfo.lock);

	return error;
}

/*
 * Manager entry
 *	(Initialization/End processing)
 */
EXPORT ER EventMgr( INT ac, UB *av[] )
{
	ER	err;

	if ( ac >= 0 ) {
		/* Initialization */
		err = initialize();
		if ( err != E_OK ) {
			/* Initialization failed */
			(void)finish();
		}
	} else {
		/* End processing */
		err = finish();
	}

	return err;
}