comfilntdevice.cpp

一个2000系统上的虚拟串口驱动程序

//
VOID ComfilntDevice::IoctlGetTimeOuts(SERIAL_TIMEOUTS& TimeOuts)
{
	TimeOuts = m_Timeouts;
}

/////////////////////////////////////////////////////////////////
// IoctlSetTimeOuts
//
VOID ComfilntDevice::IoctlSetTimeOuts(SERIAL_TIMEOUTS& TimeOuts)
{
	m_Timeouts = TimeOuts;

//	if ( (m_Timeouts.ReadIntervalTimeout != 0) &&
//		 (m_Timeouts.ReadIntervalTimeout != MAXULONG))
//	{
//		m_MaxCharacterInterval = 
//			(LONGLONG)m_Timeouts.ReadIntervalTimeout * 10000;
//
//		if (m_MaxCharacterInterval > SMALL_INTERVAL_CUTOFF)
//			m_IntervalTimerPeriod = LONG_INTERVAL;
//		else
//			m_IntervalTimerPeriod = SHORT_INTERVAL;
//	}
}

/////////////////////////////////////////////////////////////////
// IoctlGetSpecialCharacters
//
VOID ComfilntDevice::IoctlGetSpecialCharacters(SERIAL_CHARS& Chars)
{
	Chars = m_Chars;

}

/////////////////////////////////////////////////////////////////
// IoctlSetSpecialCharacters
//
VOID ComfilntDevice::IoctlSetSpecialCharacters(SERIAL_CHARS& Chars)
{
	m_Chars = Chars;
}

#if NTVERSION > 351
/////////////////////////////////////////////////////////////////
// IoctlGetStatistics
//
VOID ComfilntDevice::IoctlGetStatistics(SERIALPERF_STATS& Stats)
{
	Stats = m_Statistics;
}
/////////////////////////////////////////////////////////////////
// IoctlClearStatistics
//
VOID ComfilntDevice::IoctlClearStatistics(void)
{
	RtlZeroMemory(&m_Statistics, sizeof(SERIALPERF_STATS));
}
#endif

/////////////////////////////////////////////////////////////////
// IoctlGetWaitMask
//
ULONG ComfilntDevice::IoctlGetWaitMask(void)
{
	
	return m_WaitMask;
}

/////////////////////////////////////////////////////////////////
// IoctlSetWaitMask
//
NTSTATUS ComfilntDevice::IoctlSetWaitMask(ULONG mask)
{
	m_WaitMask = mask;
	return STATUS_SUCCESS;
}

/////////////////////////////////////////////////////////////////
// IoctlGetProperties
//
VOID ComfilntDevice::IoctlGetProperties(SERIAL_COMMPROP& Properties)
{
}

/////////////////////////////////////////////////////////////////
// IoctlGetModemStatus
//
ULONG ComfilntDevice::IoctlGetModemStatus(void)
{
	return 0;
}

/////////////////////////////////////////////////////////////////
// IoctlGetCommStatus
//
VOID ComfilntDevice::IoctlGetCommStatus(SERIAL_STATUS& CommStatus)
{
	CommStatus.Errors = 0;
	CommStatus.HoldReasons = 0;
	if((m_Unit & 1 )== 0){
		CommStatus.AmountInInQueue = m_pRW->PipeB.NumberOfItemsAvailableForRead();
		CommStatus.AmountInOutQueue = m_pRW->WriteCountA;
	}else{
		CommStatus.AmountInInQueue = m_pRW->PipeA.NumberOfItemsAvailableForRead();
		CommStatus.AmountInOutQueue = m_pRW->WriteCountB;
	}
//	t << "COM=" <<m_Unit << "; " << (ULONG)m_pRW->WriteCountA ;
//	t << "; " << (ULONG)m_pRW->WriteCountB <<EOL;
//	t << "COM=" <<m_Unit << ":: " << (ULONG)CommStatus.AmountInInQueue; 
//	t << "; " << (ULONG)CommStatus.AmountInOutQueue <<EOL;
//	CommStatus.AmountInOutQueue = m_WriteCount;
	CommStatus.EofReceived = FALSE;
	CommStatus.WaitForImmediate = FALSE;

	m_ErrorState = 0;
}


VOID ComfilntDevice::IoctlSetBaudRate(SERIAL_BAUD_RATE& BaudRate)
{
	m_BaudRate = BaudRate;
}
/////////////////////////////////////////////////////////////////
// IoctlSetQueueSize
//
NTSTATUS ComfilntDevice::IoctlSetQueueSize(SERIAL_QUEUE_SIZE& QueueSizes)
{
	return STATUS_INSUFFICIENT_RESOURCES;
}

/////////////////////////////////////////////////////////////////
// IoctlGetHandFlow
//
VOID ComfilntDevice::IoctlGetHandFlow(SERIAL_HANDFLOW& HandFlow)
{

	HandFlow = m_Handflow;
}


////////////////////////////////////////////////////////////////////////
//  ComfilntDevice::FlushBuffers
//
//	Routine Description:
//		Handler for IRP_MJ_FLUSHBUFFERS
//
//	Parameters:
//		I - Current IRP
//
//	Return Value:
//		NTSTATUS - Result code
//
//	Comments:
//		This routine handles Flush Buffer requests.

NTSTATUS ComfilntDevice::FlushBuffers(KIrp I) 
{
	t << "Entering ComfilntDevice::Flush Buffers, " << I;
	NTSTATUS status = STATUS_SUCCESS;
// TODO:	Handle flush buffer request
    return I.Complete(status);
}

////////////////////////////////////////////////////////////////////////
//  ComfilntDevice::Cleanup
//
//	Routine Description:
//		Handler for IRP_MJ_CLEANUP	
//
//	Parameters:
//		I - Current IRP
//
//	Return Value:
//		NTSTATUS	Result code
//
//	Comments:
//

NTSTATUS ComfilntDevice::CleanUp(KIrp I)
{
	t << "Entering CleanUp, " << I;

// TODO:	Insert your code to respond to the CLEANUP message.
	return I.Complete(STATUS_SUCCESS);
}


////////////////////////////////////////////////////////////////////////
//  ComfilntDevice::Create
//
//	Routine Description:
//		Handler for IRP_MJ_CREATE
//
//	Parameters:
//		I - Current IRP
//
//	Return Value:
//		NTSTATUS - Result code
//
//	Comments:
//

NTSTATUS ComfilntDevice::Create(KIrp I)
{
	t << "<<<<<<<<<<<<<<<<<<<<Entering Create>>>>>>>>>>>>>>>>> " << EOL;
	t << "Irp=" << I ;
	t << "COM=" <<m_Unit << EOL;
	if(m_IsOpened==0){
		m_IsOpened=1;
		I.Information() = 0;
		return I.Complete(STATUS_SUCCESS);
	}else{
		I.Information() = 0;
		return I.Complete(STATUS_UNSUCCESSFUL);

	}
}

////////////////////////////////////////////////////////////////////////
//  ComfilntDevice::Close
//
//	Routine Description:
//		Handler for IRP_MJ_CLOSE
//
//	Parameters:
//		I - Current IRP
//
//	Return Value:
//		NTSTATUS - Result code
//
//	Comments:
//

NTSTATUS ComfilntDevice::Close(KIrp I)
{
	t << "Entering Close, " << I << "; COM=" << m_Unit;
		m_IsOpened=0;
	I.Information() = 0;
	return I.Complete(STATUS_SUCCESS);
}

////////////////////////////////////////////////////////////////////////
//  ComfilntDevice::Shutdown
//
//	Routine Description:
//		Handler for IRP_MJ_SHUTDOWN
//
//	Parameters:
//		I - Current IRP
//
//	Return Value:
//		NTSTATUS	Result code	
//
//	Comments:
//

NTSTATUS ComfilntDevice::Shutdown(KIrp I)
{
	t << "Entering Shutdown\n";
// TODO:	Insert SHUTDOWN code

   return I.Complete(STATUS_SUCCESS);
}

//////////////////////////////////////////////////////////////////////
// IoctlGetLineControl
//
// Get current parity, data bits, and stop bits for Uart
//
VOID ComfilntDevice::IoctlGetLineControl(SERIAL_LINE_CONTROL& LineControl)
{
//	m_LineControl = m_PortLineControl;

	// Data bits
	UCHAR DataBits;
	switch (m_LineControl & SERIAL_DATA_MASK)
	{
	case SERIAL_5_DATA: DataBits = 5; break;
	case SERIAL_6_DATA: DataBits = 6; break;
	case SERIAL_7_DATA: DataBits = 7; break;
	case SERIAL_8_DATA: DataBits = 8; break;
	}
	LineControl.WordLength = DataBits;


	// Parity
	UCHAR Parity;
	if ( (m_LineControl & 8) == 0)
		Parity = NO_PARITY;
	else
		switch (m_LineControl & SERIAL_PARITY_MASK)
		{
		case SERIAL_ODD_PARITY:		Parity = ODD_PARITY;  break;
		case SERIAL_EVEN_PARITY:	Parity = EVEN_PARITY;   break;
		case SERIAL_MARK_PARITY:	Parity = MARK_PARITY;  break;
		case SERIAL_SPACE_PARITY:	Parity = SPACE_PARITY; break;
		}	
	LineControl.Parity = Parity;


	// Stop bits
	UCHAR StopBits;	
    if (m_LineControl & SERIAL_2_STOP) 
    {
        if (DataBits == 5) 
            StopBits = STOP_BITS_1_5;
        else 
            StopBits = STOP_BITS_2;
    } 
    else 
        StopBits = STOP_BIT_1;

	LineControl.StopBits = StopBits;
}

//////////////////////////////////////////////////////////////////////
// IoctlSetLineControl
//
// Set up parity, data bits, and stop bits for Uart
//
NTSTATUS ComfilntDevice::IoctlSetLineControl(SERIAL_LINE_CONTROL& LineControl)
{
	UCHAR lc=0;

	// Parity
	UCHAR Parity;
	switch (LineControl.Parity)
	{
	case NO_PARITY:		Parity = SERIAL_NONE_PARITY;  break;
	case EVEN_PARITY:	Parity = SERIAL_EVEN_PARITY;  break;
	case ODD_PARITY:	Parity = SERIAL_ODD_PARITY;   break;
	case MARK_PARITY:	Parity = SERIAL_MARK_PARITY;  break;
	case SPACE_PARITY:	Parity = SERIAL_SPACE_PARITY; break;
	default:	
		return STATUS_INVALID_PARAMETER;
	}
	lc |= Parity;

	// Data bits
	UCHAR DataBits;
	switch (LineControl.WordLength)
	{
	case 5:	DataBits = SERIAL_5_DATA; break;
	case 6:	DataBits = SERIAL_6_DATA; break;
	case 7:	DataBits = SERIAL_7_DATA; break;
	case 8:	DataBits = SERIAL_8_DATA; break;
	default:
		return STATUS_INVALID_PARAMETER;
	}
	lc |= DataBits;

	// Stop bits
	UCHAR StopBits;
	switch (LineControl.StopBits)
	{
	case STOP_BIT_1:
		StopBits = SERIAL_1_STOP;
		break;

	case STOP_BITS_1_5:	// Only valid for 5 data bits
		if (DataBits != SERIAL_5_DATA)
			return STATUS_INVALID_PARAMETER;
		StopBits = SERIAL_1_5_STOP; 
		break;

	case STOP_BITS_2:	// Not valid for 5 data bits
		if (DataBits == SERIAL_5_DATA)
			return STATUS_INVALID_PARAMETER;
		StopBits = SERIAL_2_STOP;
		break;

	default:
		return STATUS_INVALID_PARAMETER;
	}
	lc |= StopBits;

	// Do it
	
	m_LineControl = lc;
//	Synch(LinkTo(SetLineControl));

	return STATUS_SUCCESS;
}

/////////////////////////////////////////////////////////////////
// IoctlPurge
//
VOID ComfilntDevice::IoctlPurge(ULONG PurgeMask)
{
	if (PurgeMask & SERIAL_PURGE_TXABORT){
		if((m_Unit&1)==0){
			m_pRW->PipeA.Flush();
			m_pRW->MaskA &=~SERIAL_EV_RXCHAR;
			m_pRW->WriteCountA=0;
		}else{
			m_pRW->PipeB.Flush();
			m_pRW->MaskB &=~SERIAL_EV_RXCHAR;
			m_pRW->WriteCountB=0;
		}
	}
	if (PurgeMask & SERIAL_PURGE_RXABORT)
	{
		if((m_Unit&1)==0){
			m_pRW->PipeB.Flush();
			m_pRW->MaskB &=~SERIAL_EV_RXCHAR;
			m_pRW->WriteCountB=0;
		}else{
			m_pRW->PipeA.Flush();
			m_pRW->MaskA &=~SERIAL_EV_RXCHAR;
			m_pRW->WriteCountA=0;
		}
	}
}