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 (device)
 *
 *	Device management
 */

#include "devmgr.h"
#include <tstring.h>
#include <extension/sys/svc/ifdevice.h>


LOCAL WER svcentry( VP para, FN fncd );
LOCAL void breakfn( ID tskid );
LOCAL void cleanupfn( ID resid, W pid );
LOCAL ER eventfn( INT evttyp, ID resid, INT info );
LOCAL ER initialize( void );
LOCAL ER finish( void );

/*
 * Convert the device name. (TC->UB)
 */
EXPORT ER ubdevnm( UB ub_nm[L_DEVNM + 1], TC *tc_nm )
{
	W	n;

	n = tcstoeucs(NULL, tc_nm);
	if ( (n <= 0) || (n > L_DEVNM) ) {
		return E_PAR;
	}

	tcstoeucs(ub_nm, tc_nm);

	return E_OK;
}

/*
 * Convert the device name. (UB->TC)
 */
EXPORT void tcdevnm( TC *tc_nm, UB *ub_nm, W max )
{
	TC	*tp, *ep = tc_nm + max;
	W	n, i = 0;

	for ( tp = tc_nm; tp < ep; tp++ ) {
		n = euctotc(tp, ub_nm + i);
		if ( n <= 0 ) {
			break;
		}
		i += n;
		if ( i >= L_DEVNM ) {
			break;
		}
	}
	if ( tp < ep ) {
		*tp = TNULL;
	}
}

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

/*
 * Extended SVC entry
 */
LOCAL WER svcentry( VP para, FN fncd )
{

	switch ( fncd ) {
	  case DM_OPN_DEV_FN: {
		DM_OPN_DEV_PARA *p = para;
		return _tkse_opn_dev(p->devnm, p->omode);
	  }

	  case DM_CLS_DEV_FN: {
		DM_CLS_DEV_PARA *p = para;
		return _tkse_cls_dev(p->dd, p->option);
	  }

	  case DM_REA_DEV_FN: {
		DM_REA_DEV_PARA *p = para;
		return _tkse_rea_dev(p->dd, p->start, p->buf, p->size, p->tmout);
	  }

	  case DM_SREA_DEV_FN: {
		DM_SREA_DEV_PARA *p = para;
		return _tkse_srea_dev(p->dd, p->start, p->buf, p->size, p->asize);
	  }

	  case DM_WRI_DEV_FN: {
		DM_WRI_DEV_PARA *p = para;
		return _tkse_wri_dev(p->dd, p->start, p->buf, p->size, p->tmout);
	  }

	  case DM_SWRI_DEV_FN: {
		DM_SWRI_DEV_PARA *p = para;
		return _tkse_swri_dev(p->dd, p->start, p->buf, p->size, p->asize);
	  }

	  case DM_WAI_DEV_FN: {
		DM_WAI_DEV_PARA *p = para;
		return _tkse_wai_dev(p->dd, p->reqid, p->asize, p->ioer, p->tmout);
	  }

	  case DM_GET_DEV_FN: {
		DM_GET_DEV_PARA *p = para;
		return _tkse_get_dev(p->devid, p->devnm);
	  }

	  case DM_REF_DEV_FN: {
		DM_REF_DEV_PARA *p = para;
		return _tkse_ref_dev(p->devnm, p->rdev);
	  }

	  case DM_OREF_DEV_FN: {
		DM_OREF_DEV_PARA *p = para;
		return _tkse_oref_dev(p->dd, p->rdev);
	  }

	  case DM_LST_DEV_FN: {
		DM_LST_DEV_PARA *p = para;
		return _tkse_lst_dev(p->ldev, p->start, p->ndev);
	  }


	  case DM_OPN_DEV2_FN: {
		DM_OPN_DEV2_PARA *p = para;
		return _tkse_opn_dev2(p->dev, p->o_mode, p->error);
	  }

	  case DM_CLS_DEV2_FN: {
		DM_CLS_DEV2_PARA *p = para;
		return _tkse_cls_dev2(p->dd, p->option, p->error);
	  }

	  case DM_REA_DEV2_FN: {
		DM_REA_DEV2_PARA *p = para;
		return _tkse_rea_dev2(p->dd, p->start, p->buf, p->size,
						p->a_size, p->error);
	  }

	  case DM_WRI_DEV2_FN: {
		DM_WRI_DEV2_PARA *p = para;
		return _tkse_wri_dev2(p->dd, p->start, p->buf, p->size,
						p->a_size, p->error);
	  }
#if 0
	  case DM_CHG_DMD_FN: {
		DM_CHG_DMD_PARA *p = para;
		return _tkse_chg_dmd(p->dev, p->mode);
	  }
#endif
	  case DM_DEV_STS_FN: {
		DM_DEV_STS_PARA *p = para;
		return _tkse_dev_sts(p->dev, p->buf);
	  }

	  case DM_GET_DEV2_FN: {
		DM_GET_DEV2_PARA *p = para;
		return _tkse_get_dev2(p->dev, p->num);
	  }

	  case DM_LST_DEV2_FN: {
		DM_LST_DEV2_PARA *p = para;
		return _tkse_lst_dev2(p->dev, p->ndev);
	  }

	  case DM_SUS_DEV_FN: {
		DM_SUS_DEV_PARA *p = para;
		return _tkse_sus_dev(p->mode);
	  }

	  default: {
		return E_RSFN;
	  }
	}
}

/*
 * Break function
 */
LOCAL void breakfn( ID tskid )
{
	tk_dis_wai(tskid, TTX_SVC);
}

/*
 * Cleanup function
 */
LOCAL void cleanupfn( ID resid, W pid )
{
	SetSusResNotify(0, pid);
}

/*
 * Event processing function
 */
LOCAL ER eventfn( INT evttyp, ID resid, INT info )
{
	ER	err;

	switch ( evttyp ) {
	  case TSEVT_DEVICE_REGIST:
		err = UpdateAccessMode(info, TRUE);
		if ( err < E_OK ) {
			goto err_ret;
		}
		break;
	  case TSEVT_DEVICE_DELETE:
		err = UpdateAccessMode(info, FALSE);
		if ( err < E_OK ) {
			goto err_ret;
		}
		break;
	  default:
		/* nothing to do */
		break;
	}

	return E_OK;

err_ret:
	DEBUG_PRINT(("eventfn err = %d\n", err));
	return err;
}

/*
 * Initialization
 */
LOCAL ER initialize( void )
{
	T_DSSY	dssy;
	ER	err;

	/* Generate the lock for exclusive control. */
	err = CreateLock(&BDevMgrLock, (UB*)"BDev");
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* Subsystem registration */
	dssy.ssyatr    = TA_NULL;
	dssy.ssypri    = DM_PRI;
	dssy.svchdr    = (FP)svcentry;
	dssy.breakfn   = (FP)breakfn;
	dssy.startupfn = NULL;
	dssy.cleanupfn = (FP)cleanupfn;
	dssy.eventfn   = (FP)eventfn;
	dssy.resblksz  = 0;
	err = tk_def_ssy(DM_SVC, &dssy);
	if ( err < E_OK ) {
		goto err_ret;
	}

	return E_OK;

err_ret:
	DEBUG_PRINT(("initialize err = %d\n", err));
	return err;
}

/*
 * End processing
 */
LOCAL ER finish( void )
{
	ER	err, error = E_OK;

	/* Subsystem deregistration */
	err = tk_def_ssy(DM_SVC, NULL);
	if ( err < E_OK ) {
		error = err;
	}

	/* Delete the lock for exclusive control. */
	DeleteLock(&BDevMgrLock);

#ifdef DEBUG
	if ( error < E_OK ) {
		DEBUG_PRINT(("finish err = %d\n", error));
	}
#endif
	return error;
}

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

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

#ifdef DEBUG
	if ( err < E_OK ) {
		DEBUG_PRINT(("DeviceMgr err = %d\n", err));
	}
#endif
	return err;
}