devio.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.
 *
 *----------------------------------------------------------------------
 */

/*
 *	devio.c (device)
 *
 *	Device input/output
 */

#include "devmgr.h"

#define TSD_DV2_MSK_0XFFFF	0xffffU

/*
 *	T-Kernel I/F System Call
 */

/*
 * Device open
 */
EXPORT ID _tkse_opn_dev( UB *devnm, UINT omode )
{
	ER	er;

	er = ChkSpaceBstrR(devnm, 0);
	if ( er < E_OK ) {
		goto err_ret;
	}

	/* Parameter check */
	if ( (omode & ~(UW)(TD_UPDATE|TD_EXCL|TD_WEXCL|TD_REXCL)) != 0 ) {
		er = E_PAR;
		goto err_ret;
	}

	/* Check the access right. */
	er = tkCheckAccessMode(devnm, omode);
	if ( er < E_OK ) {
		goto err_ret;
	}

	/* Open */
	er = tk_opn_dev(devnm, omode);
	if ( er < E_OK ) {
		goto err_ret;
	}

	return er;

err_ret:
	return er;
}

/*
 * Device close
 */
EXPORT ER _tkse_cls_dev( ID dd, UINT option )
{
	return tk_cls_dev(dd, option);
}

/*
 * Start reading from device
 */
EXPORT ID _tkse_rea_dev( ID dd, INT start, VP buf, INT size, TMO tmout )
{
	T_RDEV	rdev;
	INT	n;
	ER	er;

	if ( start >= 0 ) {
		/* In the case of unique data */
		er = tk_oref_dev(dd, &rdev);
		if ( er < E_OK ) {
			goto err_ret;
		}

		if ( rdev.blksz <= 0 ) {
			er = E_NOMDA;
			goto err_ret;
		}
		n = rdev.blksz;
	} else {
		/* In the case of attribute data */
		n = 1;
	}

	er = ChkSpaceRW(buf, n * size);
	if ( er < E_OK ) {
		goto err_ret;
	}

	er = tk_rea_dev(dd, start, buf, size, tmout);

err_ret:
	return er;
}

/*
 * Synchronous reading from device
 */
EXPORT ER _tkse_srea_dev( ID dd, INT start, VP buf, INT size, INT *asize )
{
	ER	er, ioer;

	er = ChkSpaceRW(asize, sizeof(INT));
	if ( er < E_OK ) {
		goto err_ret;
	}

	er = _tkse_rea_dev(dd, start, buf, size, TMO_FEVR);
	if ( er < E_OK ) {
		goto err_ret;
	}

	er = tk_wai_dev(dd, er, asize, &ioer, TMO_FEVR);
	if ( er < E_OK ) {
		goto err_ret;
	}

	return ioer;

err_ret:
	return er;
}

/*
 * Start writing to device
 */
EXPORT ID _tkse_wri_dev( ID dd, INT start, VP buf, INT size, TMO tmout )
{
	T_RDEV	rdev;
	INT	n;
	ER	er;

	if ( start >= 0 ) {
		/* In the case of unique data */
		er = tk_oref_dev(dd, &rdev);
		if ( er < E_OK ) {
			goto err_ret;
		}

		if ( rdev.blksz <= 0 ) {
			er = E_NOMDA;
			goto err_ret;
		}
		n = rdev.blksz;
	} else {
		/* In the case of attribute data */
		n = 1;
	}

	er = ChkSpaceR(buf, n * size);
	if ( er < E_OK ) {
		goto err_ret;
	}

	er = tk_wri_dev(dd, start, buf, size, tmout);

err_ret:
	return er;
}

/*
 * Synchronous writing from device
 */
EXPORT ER _tkse_swri_dev( ID dd, INT start, VP buf, INT size, INT *asize )
{
	ER	er, ioer;

	er = ChkSpaceRW(asize, sizeof(INT));
	if ( er < E_OK ) {
		goto err_ret;
	}

	er = _tkse_wri_dev(dd, start, buf, size, TMO_FEVR);
	if ( er < E_OK ) {
		goto err_ret;
	}

	er = tk_wai_dev(dd, er, asize, &ioer, TMO_FEVR);
	if ( er < E_OK ) {
		goto err_ret;
	}

	return ioer;

err_ret:
	return er;
}

/*
 * Request completion wait
 */
EXPORT ID _tkse_wai_dev( ID dd, ID reqid, INT *asize, ER *ioer, TMO tmout )
{
	ER	er;

	er = ChkSpaceRW(asize, sizeof(INT));
	if ( er < E_OK ) {
		goto err_ret;
	}
	er = ChkSpaceRW(ioer, sizeof(ER));
	if ( er < E_OK ) {
		goto err_ret;
	}

	er = tk_wai_dev(dd, reqid, asize, ioer, tmout);

err_ret:
	return er;
}

/*
 * Get device name
 */
EXPORT ID _tkse_get_dev( ID devid, UB *devnm )
{
	ER	er;

	er = ChkSpaceRW(devnm, (L_DEVNM + 1) * sizeof(UB));
	if ( er < E_OK ) {
		return er;
	}

	return tk_get_dev(devid, devnm);
}

/*
 * Get device information
 */
EXPORT ID _tkse_ref_dev( UB *devnm, T_RDEV *rdev )
{
	ER	er;

	er = ChkSpaceBstrR(devnm, 0);
	if ( er < E_OK ) {
		return er;
	}
	if ( rdev != NULL ) {
		er = ChkSpaceRW(rdev, sizeof(T_RDEV));
		if ( er < E_OK ) {
			return er;
		}
	}

	return tk_ref_dev(devnm, rdev);
}

/*
 * Get device information
 */
EXPORT ID _tkse_oref_dev( ID dd, T_RDEV *rdev )
{
	ER	er;

	if ( rdev != NULL ) {
		er = ChkSpaceRW(rdev, sizeof(T_RDEV));
		if ( er < E_OK ) {
			return er;
		}
	}

	return tk_oref_dev(dd, rdev);
}

/*
 * Get registration device list
 */
EXPORT INT _tkse_lst_dev( T_LDEV *ldev, INT start, INT ndev )
{
	ER	er;

	if ( (start < 0) || (ndev < 0) ) {
		return E_PAR;
	}
	er = ChkSpaceRW(ldev, (INT)((UW)ndev * sizeof(T_LDEV)));
	if ( er < E_OK ) {
		return er;
	}

	return tk_lst_dev(ldev, start, ndev);
}


/*
 *	Conventional System Call
 */

/*
 * Device open
 */
EXPORT WER _tkse_opn_dev2( TC *dev, W o_mode, W *error )
{
	UB	devnm[L_DEVNM + 1];
	ER	err;

	err = CheckStrSpaceR(dev, 0);
	if ( err < E_OK ) {
		goto err_ret;
	}
	if ( error != NULL ) {
		err = CheckSpaceRW(error, sizeof(W));
		if ( err < E_OK ) {
			goto err_ret_nodetr;
		}
	}

	/* Parameter check */
	if ( (((UW)o_mode & ~(UW)(D_UPDATE|D_EXCL|D_WEXCL)) != 0)
	  || (((UW)o_mode & (D_EXCL|D_WEXCL)) == (D_EXCL|D_WEXCL)) ) {
		err = E_PAR;
		goto err_ret;
	}

	/* Convert the device name. */
	err = ubdevnm(devnm, dev);
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* Check the access right. */
	err = CheckAccessMode(devnm, o_mode);
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* Open */
	err = tk_opn_dev(devnm, (UINT)o_mode);
	if ( err < E_OK ) {
		err = ERtoERR(err);
		goto err_ret;
	}

	if ( error != NULL ) {
		*error = E_OK;
	}
	return err;

err_ret:
	if ( error != NULL ) {
		*error = err;
	}
err_ret_nodetr:
	DEBUG_PRINT(("_tkse_opn_dev err = %d\n", err));
	return (WER)((UW)err & ~TSD_DV2_MSK_0XFFFF);
}

/*
 * Close the device.
 */
EXPORT ER _tkse_cls_dev2( W dd, UINT option, W *error )
{
	ER	err;

	if ( error != NULL ) {
		err = CheckSpaceRW(error, sizeof(W));
		if ( err < E_OK ) {
			goto err_ret_nodetr;
		}
	}

	/* Close */
	err = tk_cls_dev(dd, option);
	if ( err < E_OK ) {
		err = ERtoERR(err);
		goto err_ret;
	}

	if ( error != NULL ) {
		*error = E_OK;
	}
	return E_OK;

err_ret:
	if ( error != NULL ) {
		*error = err;
	}
err_ret_nodetr:
	DEBUG_PRINT(("_tkse_cls_dev err = %d\n", err));
	return (WER)((UW)err & ~TSD_DV2_MSK_0XFFFF);
}

/*
 * Read
 */
EXPORT ER _tkse_rea_dev2( W dd, W start, B *buf, W size, W *a_size, W *error )
{
	T_RDEV	rdev;
	W	n;
	ER	err;

	err = CheckSpaceRW(a_size, sizeof(W));
	if ( err < E_OK ) {
		goto err_ret;
	}
	if ( error != NULL ) {
		err = CheckSpaceRW(error, sizeof(W));
		if ( err < E_OK ) {
			goto err_ret_nodetr;
		}
	}

	if ( start >= 0 ) {
		/* In the case of unique data */
		err = tk_oref_dev(dd, &rdev);
		if ( err < E_OK ) {
			err = ERtoERR(err);
			goto err_ret;
		}

		if ( rdev.blksz <= 0 ) {
			err = E_NOMDA;
			goto err_ret;
		}
		n = rdev.blksz;
	} else {
		/* In the case of attribute data */
		n = 1;
	}

	err = CheckSpaceRW(buf, n * size);
	if ( err < E_OK ) {
		goto err_ret;
	}

	err = tk_srea_dev(dd, start, buf, size, a_size);
	if ( err < E_OK ) {
		err = ERtoERR(err);
		goto err_ret;
	}

	if ( error != NULL ) {
		*error = E_OK;
	}
	return E_OK;

err_ret:
	if ( error != NULL ) {
		*error = err;
	}
err_ret_nodetr:
	DEBUG_PRINT(("_tkse_rea_dev err = %d\n", err));
	return (WER)((UW)err & ~TSD_DV2_MSK_0XFFFF);
}

/*
 * Write
 */
EXPORT ER _tkse_wri_dev2( W dd, W start, B *buf, W size, W *a_size, W *error )
{
	T_RDEV	rdev;
	W	n;
	ER	err;

	err = CheckSpaceRW(a_size, sizeof(W));
	if ( err < E_OK ) {
		goto err_ret;
	}
	if ( error != NULL ) {
		err = CheckSpaceRW(error, sizeof(W));
		if ( err < E_OK ) {
			goto err_ret_nodetr;
		}
	}

	if ( start >= 0 ) {
		/* In the case of unique data */
		err = tk_oref_dev(dd, &rdev);
		if ( err < E_OK ) {
			err = ERtoERR(err);
			goto err_ret;
		}

		if ( rdev.blksz <= 0 ) {
			err = E_NOMDA;
			goto err_ret;
		}
		n = rdev.blksz;
	} else {
		/* In the case of attribute data */
		n = 1;
	}

	err = CheckSpaceR(buf, n * size);
	if ( err < E_OK ) {
		goto err_ret;
	}

	err = tk_swri_dev(dd, start, buf, size, a_size);
	if ( err < E_OK ) {
		err = ERtoERR(err);
		goto err_ret;
	}

	if ( error != NULL ) {
		*error = E_OK;
	}
	return E_OK;

err_ret:
	if ( error != NULL ) {
		*error = err;
	}
err_ret_nodetr:
	DEBUG_PRINT(("_tkse_wri_dev err = %d\n", err));
	return err;
}