iodev.c

PNX系列设备驱动 PNX系列设备驱动

/*
COPYRIGHT (c) 1996 by Philips Semiconductors

THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED AND COPIED IN 
ACCORDANCE WITH THE TERMS AND CONDITIONS OF SUCH A LICENSE AND WITH THE 
INCLUSION OF THE THIS COPY RIGHT NOTICE. THIS SOFTWARE OR ANY OTHER COPIES 
OF THIS SOFTWARE MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY OTHER
PERSON. THE OWNERSHIP AND TITLE OF THIS SOFTWARE IS NOT TRANSFERRED. 

THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT ANY PRIOR NOTICE
AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY Philips Semiconductor. 

PHILIPS ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF THIS SOFTWARE
ON PLATFORMS OTHER THAN THE ONE ON WHICH THIS SOFTWARE IS FURNISHED.
*/
/*
	Copyright (c) 1996 Philips Semiconductors - TriMedia. All rights reserved.

FILE	iodev.c

HISTORY

	950201	Tilakraj Roy 
		Created

	970211	Tilakraj Roy
		Updated for using non COM interfaces

*/

#include "windows.h"
#include "iodev.h"

typedef struct _IODEVICE_OBJECT
{
	PVOID		pvRefObject;

	HANDLE		hIn;
	HANDLE		hOut;
	HANDLE		hErr;

	IODEV_TYPE	Input;
	IODEV_TYPE	Output;
	IODEV_TYPE	Error;

	BOOL		CommPortOpenForWrite;

	DCB		DeviceControlBlock;
	COMMTIMEOUTS	CommTimeOuts;
	HANDLE	hCommThread;
	DWORD	dwCommPort;
	DWORD	dwBaudRate;
	BYTE	bParity;
	BYTE	bStopBits;
	BYTE	bByteSize;
	DWORD	dwInQSize;
	DWORD	dwOutQSize;
	DWORD	dwThreadID;
	DWORD	dwErrorCode;

	PIODEVICE_VTBL pVTBL;

}	IODEVICE_OBJECT, *PIODEVICE_OBJECT;

BOOL	iodevOpenStdIO (PVOID pObject, DWORD dwWindowSize, IODEV_HANDLE HandleType );
BOOL	iodevOpenFile (PVOID pObject, PCHAR pszFilaname, IODEV_HANDLE HandleType );
BOOL	iodevOpenComm (PVOID pObject, DWORD dwCommPort, DWORD dwBaudRate, IODEV_HANDLE HandleType );
VOID	iodevClose (PVOID pObject );
BOOL	iodevReadChar(PVOID pObject, PVOID pBuffer, DWORD dwLength );
BOOL	iodevWriteChar(PVOID pObject, PVOID pBuffer, DWORD dwLength );
BOOL	iodevWriteStr(PVOID pObject, PSTR pszString);
BOOL	iodevGetHandles( PVOID pObject, HANDLE* StdIn, HANDLE* StdOut, HANDLE* StdErr );

// generic iodev object definition.
BOOL	iodevCreate ( PVOID *ppObject, PIODEVICE_VTBL *ppVTBL )
{
	PIODEVICE_OBJECT	pIoDev;

	if ( *ppObject == NULL )
	{
		
		if ( ( pIoDev = malloc ( sizeof ( IODEVICE_OBJECT ) ) ) == NULL )
		{	
			*ppObject = NULL;
			goto iodevCreateFAIL1;
		}
		else
		{
			*ppObject = 	pIoDev->pvRefObject = pIoDev;
		}
	}
	else
	{
		pIoDev = (PIODEVICE_OBJECT)*ppObject;
		pIoDev->pvRefObject = NULL;
		
	}

	pIoDev->CommPortOpenForWrite	= FALSE;
	pIoDev->hIn = pIoDev->hOut = pIoDev->hOut = INVALID_HANDLE_VALUE;

	if ( ( pIoDev->pVTBL = malloc ( sizeof ( IODEVICE_VTBL ) ) ) == NULL )
	{	
			goto iodevCreateFAIL2;
	}
	
	// initialize the VTBL
	
	*ppVTBL = pIoDev->pVTBL;

	pIoDev->pVTBL->OpenComm			= iodevOpenComm;
	pIoDev->pVTBL->OpenStdIO		= iodevOpenStdIO;
	pIoDev->pVTBL->OpenFile			= iodevOpenFile;
	pIoDev->pVTBL->Close			= iodevClose;
	pIoDev->pVTBL->ReadChar			= iodevReadChar;
	pIoDev->pVTBL->WriteChar		= iodevWriteChar;
	pIoDev->pVTBL->WriteStr			= iodevWriteStr;
	pIoDev->pVTBL->GetHandles		= iodevGetHandles;

	return TRUE;

iodevCreateFAIL2 :
	if ( pIoDev->pvRefObject )
		free ( pIoDev );

iodevCreateFAIL1 :
	return FALSE;
}

BOOL	iodevDestroy ( PVOID pObject )
{
	PIODEVICE_OBJECT	this = (PIODEVICE_OBJECT)pObject;
	if ( this->pvRefObject )
		free ( this->pvRefObject );
	return TRUE;
}

BOOL	iodevOpenFile (PVOID pObject, PCHAR pszFilename, IODEV_HANDLE HandleType )
{
	PIODEVICE_OBJECT	this = (PIODEVICE_OBJECT)pObject;
	DWORD	dwAccess, dwCreate;
	HANDLE	*pHandle;

	switch ( HandleType )
	{
		case IODEV_HANDLE_IN :
		pHandle = &this->hIn;
		dwAccess = GENERIC_READ;
		dwCreate = OPEN_EXISTING;
		break;

		case IODEV_HANDLE_OUT :
		pHandle = &this->hOut;
		dwAccess= GENERIC_WRITE;
		dwCreate = CREATE_ALWAYS;
		break;

		case IODEV_HANDLE_ERR :
		pHandle = &this->hErr;
		dwAccess= GENERIC_WRITE;
		dwCreate = CREATE_ALWAYS;
		break;
	}

	if ( ( *pHandle = CreateFile( pszFilename, dwAccess,
          0,                    // exclusive access
          NULL,                 // no security attrs
          dwCreate,
          FILE_ATTRIBUTE_NORMAL,
          NULL ) ) == (HANDLE) -1 )
	{
		return FALSE;
	}
	return TRUE;
}

BOOL	iodevOpenStdIO (PVOID pObject, DWORD dwWindowLines, IODEV_HANDLE HandleType )
{
	PIODEVICE_OBJECT	this = (PIODEVICE_OBJECT)pObject;
	DWORD	Mode;

	switch ( HandleType )
	{
		case IODEV_HANDLE_IN :
		this->hIn = GetStdHandle ( STD_INPUT_HANDLE );

		//turn echoing & line buffering off 
		GetConsoleMode ( this->hIn, &Mode  );
		Mode &=	~( ENABLE_LINE_INPUT |  ENABLE_ECHO_INPUT );
		SetConsoleMode ( this->hIn, Mode  );
		break;

		case IODEV_HANDLE_OUT :
		this->hOut = GetStdHandle ( STD_OUTPUT_HANDLE );
		if ( (dwWindowLines != 0 ) )
		{
			COORD   ConsoleSize;

			ConsoleSize.X = 80;
			ConsoleSize.Y = (WORD)dwWindowLines;
			SetConsoleScreenBufferSize ( this->hOut, ConsoleSize );
		}
		break;

		case IODEV_HANDLE_ERR :
		this->hErr = GetStdHandle ( STD_ERROR_HANDLE );
		break;
	}
	return TRUE;
}

BOOL	iodevOpenComm (PVOID pObject, DWORD dwCommPort, DWORD dwBaudRate, IODEV_HANDLE HandleType )
{
	PIODEVICE_OBJECT	this = (PIODEVICE_OBJECT)pObject;

	HANDLE	*pHandle;
	DWORD	dwAccess = 0;
	DWORD	Error;
	CHAR	szName[MAX_PATH];

	switch ( HandleType )
	{
		case IODEV_HANDLE_IN :
		pHandle = &this->hIn;
		dwAccess = GENERIC_READ | GENERIC_WRITE;
		break;

		case IODEV_HANDLE_OUT :
		case IODEV_HANDLE_ERR :
		this->hErr = this->hOut = this->hIn;
		return TRUE;
	}

	wsprintf(szName,"COM%d", dwCommPort);

	if ( ( *pHandle =
		CreateFile( (char *)szName, dwAccess,
	          0,                    // exclusive access
	          NULL,                 // no security attrs
	          OPEN_EXISTING,
	          FILE_ATTRIBUTE_NORMAL, // | FILE_FLAG_OVERLAPPED,
	          NULL )) == (HANDLE) -1 )
	{
		Error = GetLastError();
		return	FALSE;
	}
	


	// com port specific stuff
	this->dwInQSize 	= 1024 * 4;
	this->dwOutQSize 	= 1024 * 4;
	this->dwBaudRate 	= dwBaudRate;//CBR_9600;
	this->bParity 		= NOPARITY;
	this->bStopBits 	= ONESTOPBIT;
	this->bByteSize 	= 8;

	SetupComm (	*pHandle, this->dwInQSize, this->dwOutQSize );

	if ( GetCommState (  
		*pHandle, &this->DeviceControlBlock) == FALSE )
	{
		Error = GetLastError();
		return FALSE;
	}

	this->DeviceControlBlock.BaudRate	= this->dwBaudRate;
	this->DeviceControlBlock.Parity		= this->bParity;
	this->DeviceControlBlock.StopBits	= this->bStopBits;
	this->DeviceControlBlock.ByteSize	= this->bByteSize;
	this->DeviceControlBlock.fTXContinueOnXoff = FALSE;
	this->DeviceControlBlock.fBinary	= TRUE;
	this->DeviceControlBlock.fParity	= FALSE;
	this->DeviceControlBlock.fOutX		= TRUE;
	this->DeviceControlBlock.fInX		= TRUE;
//	this->DeviceControlBlock.fOutxCtsFlow	= TRUE;
//	this->DeviceControlBlock.fRtsControl	= RTS_CONTROL_ENABLE;

	SetCommState ( *pHandle, &this->DeviceControlBlock);

	this->CommTimeOuts.ReadIntervalTimeout = 0;//0xFFFFFFFF ;
	this->CommTimeOuts.ReadTotalTimeoutMultiplier = 0 ;
	this->CommTimeOuts.ReadTotalTimeoutConstant = 0;//1000 ;
	this->CommTimeOuts.WriteTotalTimeoutMultiplier = 0;//1 ;
	this->CommTimeOuts.WriteTotalTimeoutConstant = 0;//1000 ;

	SetCommTimeouts ( *pHandle, &this->CommTimeOuts ) ;

	EscapeCommFunction ( *pHandle, SETDTR ) ;


	return TRUE;
}


VOID	iodevClose (PVOID pObject )
{
	PIODEVICE_OBJECT	this = (PIODEVICE_OBJECT)pObject;
	BOOL			fCommClosed = FALSE;

	if ( this->Input != IODEV_TYPE_STDIO )
	{
		if ( this->hIn != INVALID_HANDLE_VALUE )CloseHandle(this->hIn);
	}

	if ( this->Output != IODEV_TYPE_STDIO )
	{
		if ( this->hOut != INVALID_HANDLE_VALUE ) CloseHandle(this->hOut);
		this->CommPortOpenForWrite == FALSE;
	}

	if ( this->Error == IODEV_TYPE_FILE )
	{
		if ( this->hErr != INVALID_HANDLE_VALUE ) CloseHandle(this->hErr);
	}
}

BOOL	iodevReadChar(PVOID pObject, PVOID pBuffer, DWORD dwLength )
{
	PIODEVICE_OBJECT	this = (PIODEVICE_OBJECT)pObject;
	BOOL	fReadStat;
	DWORD	dwBytesRead;
	return ( fReadStat = ReadFile( this->hIn, pBuffer,
		dwLength, &dwBytesRead, NULL ) );
}

BOOL	iodevWriteChar(PVOID pObject, PVOID pBuffer, DWORD dwLength )
{
	PIODEVICE_OBJECT	this = (PIODEVICE_OBJECT)pObject;
	BOOL	fWriteStat;
	DWORD	dwBytesWritten;
	return (fWriteStat = WriteFile( this->hOut, pBuffer,
		dwLength, &dwBytesWritten, NULL ) ) ;
}

BOOL	iodevWriteStr(PVOID pObject, PSTR pszString)
{
	PIODEVICE_OBJECT	this = (PIODEVICE_OBJECT)pObject;
	return  this->pVTBL->WriteChar ( this, pszString, strlen (pszString) );
}

BOOL	iodevGetHandles( PVOID pObject, HANDLE* StdIn, HANDLE* StdOut, HANDLE* StdErr )
{
	PIODEVICE_OBJECT	this = (PIODEVICE_OBJECT)pObject;

	StdIn = this->hIn;
	StdOut = this->hOut;
	StdErr = this->hErr;

	return TRUE;
}