device.c

日本著名的的嵌入式实时操作系统T-Kernel的源码及用户手册。

{
	DevCB	*devcb;
	ER	err;

	err = ChkSpaceRW(devnm, (L_DEVNM + 1) * sizeof(UB));
	if ( err < E_OK ) goto err_ret1;
	err = check_devid(devid);
	if ( err < E_OK ) goto err_ret1;

	LockDM();

	devcb = DEVCB(devid);
	if ( devcb->devnm[0] == '\0' ) { err = E_NOEXS; goto err_ret2; }

	logdevnm(devnm, devcb->devnm, UNITNO(devid));

	UnlockDM();

	return DID(devcb);

err_ret2:
	UnlockDM();
err_ret1:
	DEBUG_PRINT(("_tk_get_dev err = %d\n", err));
	return err;
}

/*
 * Get device information
 */
LOCAL ID _tk_ref_dev( UB *devnm, T_RDEV *rdev )
{
	UB	pdevnm[L_DEVNM + 1];
	DevCB	*devcb;
	INT	unitno;
	ER	err;

	err = ChkSpaceBstrR(devnm, 0);
	if ( err < E_OK ) goto err_ret1;
	if ( rdev != NULL ) {
		err = ChkSpaceRW(rdev, sizeof(T_RDEV));
		if ( err < E_OK ) goto err_ret1;
	}

	unitno = phydevnm(pdevnm, devnm);

	LockDM();

	devcb = searchDevCB(pdevnm);
	if ( devcb == NULL || unitno > devcb->ddev.nsub )
		{ err = E_NOEXS; goto err_ret2; }

	if ( rdev != NULL ) {
		rdev->devatr = devcb->ddev.devatr;
		rdev->blksz  = devcb->ddev.blksz;
		rdev->nsub   = devcb->ddev.nsub;
		rdev->subno  = unitno;
	}

	UnlockDM();

	return DEVID(devcb, unitno);

err_ret2:
	UnlockDM();
err_ret1:
	DEBUG_PRINT(("_tk_ref_dev err = %d\n", err));
	return err;
}

/*
 * Get device information
 */
LOCAL ID _tk_oref_dev( ID dd, T_RDEV *rdev )
{
	OpnCB	*opncb;
	DevCB	*devcb;
	INT	unitno;
	ER	err;

	if ( rdev != NULL ) {
		err = ChkSpaceRW(rdev, sizeof(T_RDEV));
		if ( err < E_OK ) goto err_ret1;
	}

	LockDM();

	err = check_devdesc(dd, 0, &opncb);
	if ( err < E_OK ) goto err_ret2;

	devcb  = opncb->devcb;
	unitno = opncb->unitno;

	if ( rdev != NULL ) {
		rdev->devatr = devcb->ddev.devatr;
		rdev->blksz  = devcb->ddev.blksz;
		rdev->nsub   = devcb->ddev.nsub;
		rdev->subno  = unitno;
	}

	UnlockDM();

	return DEVID(devcb, unitno);

err_ret2:
	UnlockDM();
err_ret1:
	DEBUG_PRINT(("_tk_oref_dev err = %d\n", err));
	return err;
}

/*
 * Get registration device list
 */
LOCAL INT _tk_lst_dev( T_LDEV *ldev, INT start, INT ndev )
{
	DevCB	*devcb;
	QUEUE	*q;
	INT	n, end;
	ER	err;

	if ( start < 0 || ndev < 0 ) { err = E_PAR; goto err_ret; }
	err = ChkSpaceRW(ldev, ndev * sizeof(T_LDEV));
	if ( err < E_OK ) goto err_ret;

	LockDM();

	end = start + ndev;
	n = 0;
	for ( q = UsedDevCB.next; q != &UsedDevCB; q = q->next ) {
		if ( n >= start && n < end ) {
			devcb = (DevCB*)q;
			ldev->devatr = devcb->ddev.devatr;
			ldev->blksz  = devcb->ddev.blksz;
			ldev->nsub   = devcb->ddev.nsub;
			strncpy(ldev->devnm, devcb->devnm, L_DEVNM);
			ldev++;
		}
		n++;
	}

	UnlockDM();

	if ( start >= n ) { err = E_NOEXS; goto err_ret; }

	return n - start;

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

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

/*
 * Send driver request event
 */
LOCAL INT _tk_evt_dev( ID devid, INT evttyp, VP evtinf )
{
	DevCB	*devcb;
	INT	(*eventfn)( INT evttyp, VP evtinf, VP exinf );
	VP	exinf;
#if TA_GP
	VP	gp;
#endif
	ER	err;

	err = check_devid(devid);
	if ( err < E_OK ) goto err_ret1;
	if ( evttyp < 0 ) { err = E_PAR; goto err_ret1; }

	LockDM();

	devcb = DEVCB(devid);
	if ( devcb->devnm[0] == '\0' ) { err = E_NOEXS; goto err_ret2; }

	eventfn = (VP)devcb->ddev.eventfn;
	exinf = devcb->ddev.exinf;
#if TA_GP
	gp = devcb->ddev.gp;
#endif

	UnlockDM();

	/* Device driver call */
#if TA_GP
	err = CallDeviceDriver(evttyp, evtinf, exinf, 0, eventfn, gp);
#else
	err = (*eventfn)(evttyp, evtinf, exinf);
#endif

	return err;

err_ret2:
	UnlockDM();
err_ret1:
	DEBUG_PRINT(("_tk_evt_dev err = %d\n", err));
	return err;
}

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

/*
 * Extension SVC entry
 */
LOCAL INT devmgr_svcentry( VP pk_para, FN fncd, VP caller_gp )
{
	ER	err;

	/* Test call protection level */
	err = ChkCallPLevel();
	if ( err < E_OK ) goto err_ret;

	switch ( fncd ) {
	  case DEVICE_TK_OPN_DEV_FN:
		{ DEVICE_TK_OPN_DEV_PARA *p = pk_para;
		return _tk_opn_dev(p->devnm, p->omode); }
	  case DEVICE_TK_CLS_DEV_FN:
		{ DEVICE_TK_CLS_DEV_PARA *p = pk_para;
		return _tk_cls_dev(p->dd, p->option); }
	  case DEVICE_TK_REA_DEV_FN:
		{ DEVICE_TK_REA_DEV_PARA *p = pk_para;
		return _tk_rea_dev(p->dd, p->start, p->buf, p->size,
							p->tmout); }
	  case DEVICE_TK_SREA_DEV_FN:
		{ DEVICE_TK_SREA_DEV_PARA *p = pk_para;
		return _tk_srea_dev(p->dd, p->start, p->buf, p->size,
							p->asize); }
	  case DEVICE_TK_WRI_DEV_FN:
		{ DEVICE_TK_WRI_DEV_PARA *p = pk_para;
		return _tk_wri_dev(p->dd, p->start, p->buf, p->size,
							p->tmout); }
	  case DEVICE_TK_SWRI_DEV_FN:
		{ DEVICE_TK_SWRI_DEV_PARA *p = pk_para;
		return _tk_swri_dev(p->dd, p->start, p->buf, p->size,
							p->asize); }
	  case DEVICE_TK_WAI_DEV_FN:
		{ DEVICE_TK_WAI_DEV_PARA *p = pk_para;
		return _tk_wai_dev(p->dd, p->reqid, p->asize, p->ioer,
							p->tmout); }
	  case DEVICE_TK_SUS_DEV_FN:
		{ DEVICE_TK_SUS_DEV_PARA *p = pk_para;
		return _tk_sus_dev(p->mode); }
	  case DEVICE_TK_GET_DEV_FN:
		{ DEVICE_TK_GET_DEV_PARA *p = pk_para;
		return _tk_get_dev(p->devid, p->devnm); }
	  case DEVICE_TK_REF_DEV_FN:
		{ DEVICE_TK_REF_DEV_PARA *p = pk_para;
		return _tk_ref_dev(p->devnm, p->rdev); }
	  case DEVICE_TK_OREF_DEV_FN:
		{ DEVICE_TK_OREF_DEV_PARA *p = pk_para;
		return _tk_oref_dev(p->dd, p->rdev); }
	  case DEVICE_TK_LST_DEV_FN:
		{ DEVICE_TK_LST_DEV_PARA *p = pk_para;
		return _tk_lst_dev(p->ldev, p->start, p->ndev); }
	  case DEVICE_TK_EVT_DEV_FN:
		{ DEVICE_TK_EVT_DEV_PARA *p = pk_para;
		return _tk_evt_dev(p->devid, p->evttyp, p->evtinf); }
	  case DEVICE_TK_DEF_DEV_FN:
		{ DEVICE_TK_DEF_DEV_PARA *p = pk_para;
		return _tk_def_dev(p->devnm, p->ddev, p->idev, caller_gp); }
	  case DEVICE_TK_REF_IDV_FN:
		{ DEVICE_TK_REF_IDV_PARA *p = pk_para;
		return _tk_ref_idv(p->idev); }
	}
	err = E_RSFN;
err_ret:
	DEBUG_PRINT(("devmgr_svcentry err = %d\n", err));
	return err;
}

/*
 * Initialization of system management
 */
EXPORT ER initialize_devmgr( void )
{
	T_DSSY	dssy;
	T_CSEM	csem;
	ER	err;

	/* Generate lock for device management exclusive control */
	err = CreateMLock(&DevMgrLock, "DMLk");
	if ( err < E_OK ) goto err_ret;

	/* Generate semaphore for device management synchronous control */
	SetOBJNAME(csem.exinf, "DMSy");
	csem.sematr  = TA_TFIFO | TA_FIRST;
	csem.isemcnt = 0;
	csem.maxsem  = 1;
	err = tk_cre_sem(&csem);
	if ( err < E_OK ) goto err_ret;
	DevMgrSync = err;

	/* Generate device registration information table */
	err = initDevCB();
	if ( err < E_OK ) goto err_ret;

	/* Initialization of device input/output-related */
	err = initDevIO();
	if ( err < E_OK ) goto err_ret;

	/* Initialization of device initial setting information */
	err = initIDev();
	if ( err < E_OK ) goto err_ret;

	/* Subsystem registration */
	dssy.ssyatr    = TA_NULL;
	dssy.ssypri    = DEVICE_PRI;
	dssy.svchdr    = (FP)&devmgr_svcentry;
	dssy.breakfn   = (FP)&devmgr_break;
	dssy.startupfn = (FP)&devmgr_startup;
	dssy.cleanupfn = (FP)&devmgr_cleanup;
	dssy.eventfn   = NULL;
	dssy.resblksz  = sizeof(ResCB);
	err = tk_def_ssy(DEVICE_SVC, &dssy);
	if ( err < E_OK ) goto err_ret;

	return E_OK;

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

/*
 * Finalization sequence of system management 
 */
EXPORT ER finish_devmgr( void )
{
	ER	err, error = E_OK;

	/* Unregister subsystem */
	err = tk_def_ssy(DEVICE_SVC, NULL);
	if ( err < E_OK ) error = err;

	/* Unregister device initial setting information */
	err = delIDev();
	if ( err < E_OK ) error = err;

	/* Finalization sequence of device input/output-related */
	err = finishDevIO();
	if ( err < E_OK ) error = err;

	/* Delete device registration information table */
	if ( DevCBtbl != NULL ) { Ifree(DevCBtbl); DevCBtbl = NULL; }

	/* Delete semaphore for device management synchronous control */
	if ( DevMgrSync > 0 ) { tk_del_sem(DevMgrSync); DevMgrSync = 0; }

	/* Delete lock for device management exclusive control */
	DeleteMLock(&DevMgrLock);

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