device.c

使用广泛的日本著名的开源嵌入式实时操作系统T-Kernel的源码

	if ( ercd < E_OK ) {
		goto err_ret1;
	}
	ercd = check_devid(devid);
	if ( ercd < E_OK ) {
		goto err_ret1;
	}

	LockDM();

	devcb = DEVCB(devid);
	if ( (devcb->devnm[0] == '\0')||(UNITNO(devid) > devcb->ddev.nsub) ) {
		ercd = 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 ercd = %d\n", ercd));
	return ercd;
}

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

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

	unitno = phydevnm(pdevnm, devnm);

	LockDM();

	devcb = searchDevCB(pdevnm);
	if ( devcb == NULL || unitno > devcb->ddev.nsub ) {
		ercd = 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 ercd = %d\n", ercd));
	return ercd;
}

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

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

	LockDM();

	ercd = check_devdesc(dd, 0, &opncb);
	if ( ercd < 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 ercd = %d\n", ercd));
	return ercd;
}

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

	if ( start < 0 || ndev < 0 ) {
		ercd = E_PAR;
		goto err_ret;
	}
	ercd = ChkSpaceRW(ldev, ndev * (INT)sizeof(T_LDEV));
	if ( ercd < 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((char*)ldev->devnm, (char*)devcb->devnm, L_DEVNM);
			ldev++;
		}
		n++;
	}

	UnlockDM();

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

	return n - start;

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

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

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

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

	LockDM();

	devcb = DEVCB(devid);
	if ( (devcb->devnm[0] == '\0')||(UNITNO(devid) > devcb->ddev.nsub) ) {
		ercd = E_NOEXS;
		goto err_ret2;
	}

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

	UnlockDM();

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

	return ercd;

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

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

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

	/* Test call protection level */
	ercd = ChkCallPLevel();
	if ( ercd < 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); }
	  default:
		ercd = E_RSFN;
	}
err_ret:
	DEBUG_PRINT(("devmgr_svcentry ercd = %d\n", ercd));
	return ercd;
}

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

	/* Generate lock for device management exclusive control */
	ercd = CreateMLock(&DevMgrLock, OBJNAME_DMLOCK);
	if ( ercd < E_OK ) {
		goto err_ret;
	}

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

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

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

	/* Initialization of device initial setting information */
	ercd = initIDev();
	if ( ercd < 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);
	ercd = tk_def_ssy(DEVICE_SVC, &dssy);
	if ( ercd < E_OK ) {
		goto err_ret;
	}

	return E_OK;

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

/*
 * Finalization sequence of system management 
 */
EXPORT ER finish_devmgr( void )
{
	ER	ercd;

	/* Unregister subsystem */
	ercd = tk_def_ssy(DEVICE_SVC, NULL);
#ifdef DEBUG
	if ( ercd < E_OK ) {
		DEBUG_PRINT(("1. finish_devmgr -> tk_def_ssy ercd = %d\n", ercd));
	}
#endif

	/* Unregister device initial setting information */
	ercd = delIDev();
#ifdef DEBUG
	if ( ercd < E_OK ) {
		DEBUG_PRINT(("2. finish_devmgr -> delIDev ercd = %d\n", ercd));
	}
#endif

	/* Finalization sequence of device input/output-related */
	ercd = finishDevIO();
#ifdef DEBUG
	if ( ercd < E_OK ) {
		DEBUG_PRINT(("3. finish_devmgr -> finishDevIO ercd = %d\n", ercd));
	}
#endif

	/* 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);

	return ercd;
}