devlib.c

深圳市微逻辑电子有限公司 巨果&#8226 Kingmos&reg 系统核心

#include <eframe.h>
#include <efile.h>
#include <eudevice.h>
#include <edevice.h>
#include <eapisrv.h>
#include <epcore.h>
#include <devdrv.h>
#include <miscellany.h>
//#define CALL_TRAP
//        64M     256S
//FFFF HMMM MMMF SSSS SSSS PPPP 0000 0000
//#define API_MAKE( id, option, arg_num ) ( ( id << 22 ) | ( option << 12 ) | (arg_num << 8) )

//#undef CALL_TRAP
typedef HANDLE ( WINAPI * PDEV_REGISTER )( LPCTSTR lpDevName, UINT index, LPCTSTR lpszLib, DWORD dwParam );
HANDLE WINAPI Dev_RegisterDevice( LPCTSTR lpDevName, UINT index, LPCTSTR lpszLib, DWORD dwParam )
{
//	RETAILMSG( 1, ( "Dev_Register:%s,lpDriver=%x.\r\n", lpDevName, lpDriver ) );
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV, DEV_REGISTER, 4 );
    cs.arg0 = (DWORD)lpDevName;
    return (HANDLE)CALL_SERVER( &cs, index, lpszLib, dwParam );
#else
	PDEV_REGISTER pRegister;// = (PDEV_REGISTER)lpDeviceAPI[DEV_REGISTER];

	CALLSTACK cs;
	HANDLE  retv = NULL;

	if( API_Enter( API_DEV, DEV_REGISTER, &pRegister, &cs ) )
	{
		lpDevName = MapProcessPtr( lpDevName, (LPPROCESS)cs.lpvData );

		retv = pRegister( lpDevName, index, lpszLib, dwParam );

		API_Leave(  );
	}
	return retv;
#endif
}
/*
HANDLE WINAPI Dev_RegisterDriver( 
                    LPCTSTR lpDevName, 
                    UINT index, 
                    const DEVICE_DRIVER FAR * lpDriver, 
                    DWORD dwParam )
{
	return Device_RegisterDriver( lpDevName, index, lpDriver, dwParam );
}
*/

typedef BOOL ( WINAPI * PDEV_DEREGISTER )( HANDLE );
BOOL WINAPI Dev_Deregister( HANDLE handle )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV, DEV_DEREGISTER, 1 );
    cs.arg0 = (DWORD)handle ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PDEV_DEREGISTER pDeregister;// = (PDEV_DEREGISTER)lpDeviceAPI[DEV_DEREGISTER];

	CALLSTACK cs;
	BOOL  retv = FALSE;

	if( API_Enter( API_DEV, DEV_DEREGISTER, &pDeregister, &cs ) )
	{
		retv = pDeregister( handle );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PDEV_ENUM )( LPTSTR lpszDevList, LPDWORD lpdwBuflen );
DWORD WINAPI Dev_Enum( LPTSTR lpszDevList, LPDWORD lpdwBuflen )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV, DEV_ENUM, 2 );
    cs.arg0 = (DWORD)lpszDevList;
    return (DWORD)CALL_SERVER( &cs, lpdwBuflen );
#else

	PDEV_ENUM pfn;

	CALLSTACK cs;
	BOOL  retv = ERROR_SUCCESS;

	if( API_Enter( API_DEV, DEV_ENUM, &pfn, &cs ) )
	{
		lpszDevList = MapProcessPtr( lpszDevList, (LPPROCESS)cs.lpvData );
		lpdwBuflen = MapProcessPtr( lpdwBuflen, (LPPROCESS)cs.lpvData );

		retv = pfn( lpszDevList, lpdwBuflen );
		API_Leave(  );
	}
	return retv;

#endif
}

typedef BOOL ( WINAPI * PDEV_REGISTERFSD )( LPCTSTR lpcszFSDName, HANDLE hFSD, const FSDINITDRV * lpfsd );
API_TYPE BOOL WINAPI Dev_RegisterFSD( LPCTSTR lpcszFSDName, HANDLE hFSD, const FSDINITDRV * lpfsd )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV, DEV_REGISTERFSD, 3 );
    cs.arg0 = (DWORD)lpcszFSDName;
    return (DWORD)CALL_SERVER( &cs, hFSD, lpfsd );
#else

	PDEV_REGISTERFSD pfn;

	CALLSTACK cs;
	BOOL  retv = FALSE;

	if( API_Enter( API_DEV, DEV_REGISTERFSD, &pfn, &cs ) )
	{
		lpcszFSDName = MapProcessPtr( lpcszFSDName, (LPPROCESS)cs.lpvData );

		retv = pfn( lpcszFSDName, hFSD, lpfsd );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PDEV_UNREGISTERFSD )( LPCTSTR lpcszFSDName );
API_TYPE BOOL WINAPI Dev_UnregisterFSD( LPCTSTR lpcszFSDName )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV, DEV_UNREGISTERFSD, 1 );
    cs.arg0 = (DWORD)lpcszFSDName ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PDEV_UNREGISTERFSD pfn;

	CALLSTACK cs;
	BOOL  retv = FALSE;

	if( API_Enter( API_DEV, DEV_UNREGISTERFSD, &pfn, &cs ) )
	{
		lpcszFSDName = MapProcessPtr( lpcszFSDName, (LPPROCESS)cs.lpvData );

		retv = pfn( lpcszFSDName );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PDEV_LOADFSD )( HANDLE hDevice, LPCTSTR lpcszFSDName );
BOOL WINAPI Dev_LoadFSD ( HANDLE hDevice, LPCTSTR lpcszFSDName )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV, DEV_LOADFSD, 2 );
    cs.arg0 = (DWORD)hDevice;
    return (DWORD)CALL_SERVER( &cs, lpcszFSDName );
#else

	PDEV_LOADFSD pfn;

	CALLSTACK cs;
	BOOL  retv = FALSE;

	if( API_Enter( API_DEV, DEV_LOADFSD, &pfn, &cs ) )
	{
		lpcszFSDName = MapProcessPtr( lpcszFSDName, (LPPROCESS)cs.lpvData );

		retv = pfn( hDevice, lpcszFSDName );


		API_Leave(  );
		//RETAILMSG( 1, ( "UUUU.\r\n" ) );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PDEV_UNLOADFSD )( HANDLE hDevice );
BOOL WINAPI Dev_UnloadFSD ( HANDLE hDevice )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV, DEV_UNLOADFSD, 1 );
    cs.arg0 = (DWORD)hDevice;
    return (DWORD)CALL_SERVER( &cs );
#else

	PDEV_UNLOADFSD pfn;

	CALLSTACK cs;
	BOOL  retv = FALSE;

	if( API_Enter( API_DEV, DEV_UNLOADFSD, &pfn, &cs ) )
	{
		retv = pfn( hDevice );
		API_Leave();
	}
	return retv;
#endif
}


typedef HANDLE ( WINAPI * PDEV_CREATE )( LPCTSTR lpszName, DWORD dwAccess, DWORD dwShareMode, HANDLE hProc );
HANDLE WINAPI Dev_CreateFile( LPCTSTR lpszName, DWORD dwAccess, DWORD dwShareMode, HANDLE hProc )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV_FILE, DEV_CREATEFILE, 4 );
    cs.arg0 = (DWORD)lpszName;
    return (HANDLE)CALL_SERVER( &cs, dwAccess, dwShareMode, hProc );
#else

	PDEV_CREATE pCreate;

	CALLSTACK cs;
	HANDLE  retv = NULL;

	if( API_Enter( API_DEV_FILE, DEV_CREATEFILE, &pCreate, &cs ) )
	{
		lpszName = MapProcessPtr( lpszName, (LPPROCESS)cs.lpvData );

		retv = pCreate( lpszName, dwAccess, dwShareMode, hProc );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PDEV_CLOSE )(HANDLE hOpenFile);
BOOL WINAPI Dev_CloseFile( HANDLE hOpenFile )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV_FILE, DEV_CLOSEFILE, 1 );
    cs.arg0 = (DWORD)hOpenFile ;
    return (DWORD)CALL_SERVER( &cs );
#else

	PDEV_CLOSE pClose;

	CALLSTACK cs;
	BOOL  retv = FALSE;

	if( API_Enter( API_DEV_FILE, DEV_CLOSEFILE, &pClose, &cs ) )
	{
		retv = pClose( hOpenFile );
		API_Leave(  );
	}
	return retv;
#endif
}

typedef BOOL ( WINAPI * PDEV_READFILE )( HANDLE hOpenFile, LPVOID lpvBuffer, DWORD dwBytesToRead, LPDWORD lpdwNumBytesRead, LPOVERLAPPED lpOverlapped );
BOOL WINAPI Dev_ReadFile( HANDLE hOpenFile, 
						  LPVOID lpvBuffer, 
						  DWORD dwBytesToRead, 
						  LPDWORD lpdwNumBytesRead, 
						  LPOVERLAPPED lpOverlapped )
{
#ifdef CALL_TRAP
    CALLTRAP cs;
    cs.apiInfo = CALL_API( API_DEV_FILE, DEV_READFILE, 5 );
    cs.arg0 = (DWORD)hOpenFile;
    return (DWORD)CALL_SERVER( &cs, lpvBuffer, dwBytesToRead, lpdwNumBytesRead, lpOverlapped );
#else

	PDEV_READFILE pReadFile;

	CALLSTACK cs;
	BOOL  retv = FALSE;

	if( API_Enter( API_DEV_FILE, DEV_READFILE, &pReadFile, &cs ) )
	{
		lpvBuffer = MapProcessPtr( lpvBuffer, (LPPROCESS)cs.lpvData );
		lpdwNumBytesRead = MapProcessPtr( lpdwNumBytesRead, (LPPROCESS)cs.lpvData );
		lpOverlapped = MapProcessPtr( lpOverlapped, (LPPROCESS)cs.lpvData );

		retv = pReadFile( hOpenFile, lpvBuffer, dwBytesToRead, lpdwNumBytesRead, lpOverlapped );
		API_Leave(  );
	}
	return retv;
#endif
}