📄 comfilntdevice.cpp
字号:
break;
///////////////////////////////////////////////////////////////////
// Set Handshake / Flow control
//(64h--25)
case IOCTL_SERIAL_SET_HANDFLOW:
{
t <<"SetHandflow" << EOL;
SERIAL_HANDFLOW& hf = *(SERIAL_HANDFLOW*)I.IoctlBuffer();
// GTRACE((TLEVEL,"- Handshake=%x, FlowReplace=%x", hf.ControlHandShake, hf.FlowReplace));
// Validate parameters
if (I.IoctlInputBufferSize() < sizeof(SERIAL_HANDFLOW) )
status = STATUS_BUFFER_TOO_SMALL;
else if ( (hf.ControlHandShake & SERIAL_CONTROL_INVALID) ||
(hf.FlowReplace & SERIAL_FLOW_INVALID) ||
((hf.ControlHandShake & SERIAL_DTR_MASK) == SERIAL_DTR_MASK) ||
(hf.XonLimit < 0) ||
(hf.XoffLimit < 0)
)
status = STATUS_INVALID_PARAMETER;
else
status = IoctlSetHandFlow(hf);
break;
}
///////////////////////////////////////////////////////////////////
// Set DTR
//(24h--9)
case IOCTL_SERIAL_SET_DTR:
t <<"SetDTR" << EOL;
// IoctlSetDTR(TRUE);
I.Information() = 0;
status = STATUS_SUCCESS;
break;
///////////////////////////////////////////////////////////////////
// Clear DTR
//(28h--10)
case IOCTL_SERIAL_CLR_DTR:
t <<"CLRDTR" << EOL;
// IoctlSetDTR(FALSE);
I.Information() = 0;
status = STATUS_SUCCESS;
break;
///////////////////////////////////////////////////////////////////
// Set RTS
//(30h--12)
case IOCTL_SERIAL_SET_RTS:
t <<"SetRTS" << EOL;
// IoctlSetRTS(TRUE);
I.Information() = 0;
status = STATUS_SUCCESS;
break;
///////////////////////////////////////////////////////////////////
// Clear RTS
//(34h--13)
case IOCTL_SERIAL_CLR_RTS:
t <<"CLRRTS" << EOL;
// IoctlSetRTS(FALSE);
I.Information() = 0;
status = STATUS_SUCCESS;
break;
///////////////////////////////////////////////////////////////////
// Get Special Characters
//(58h--22)
case IOCTL_SERIAL_GET_CHARS:
t <<"GetCHARS" << EOL;
if (I.IoctlOutputBufferSize() < sizeof(SERIAL_CHARS) )
status = STATUS_BUFFER_TOO_SMALL;
else
{
IoctlGetSpecialCharacters( *(SERIAL_CHARS*)I.IoctlBuffer());
I.Information() = sizeof(SERIAL_CHARS);
status = STATUS_SUCCESS;
}
break;
///////////////////////////////////////////////////////////////////
// Set Special Characters
//(5ch--23)
case IOCTL_SERIAL_SET_CHARS:
{
t <<"SetCHARS" << EOL;
SERIAL_CHARS* p = (SERIAL_CHARS*)I.IoctlBuffer();
if (I.IoctlInputBufferSize() < sizeof(SERIAL_CHARS) )
status = STATUS_BUFFER_TOO_SMALL;
else
{
IoctlSetSpecialCharacters( *(SERIAL_CHARS*)I.IoctlBuffer());
status = STATUS_SUCCESS;
}
break;
}
///////////////////////////////////////////////////////////////////
// Set Timeouts
//(1ch--7)
case IOCTL_SERIAL_SET_TIMEOUTS:
{
t <<"SetTIMEOUT" << EOL;
SERIAL_TIMEOUTS* p=(SERIAL_TIMEOUTS*)I.IoctlBuffer();
if (I.IoctlInputBufferSize() < sizeof(SERIAL_TIMEOUTS) )
return STATUS_BUFFER_TOO_SMALL;
else
{
IoctlSetTimeOuts( *(SERIAL_TIMEOUTS*)I.IoctlBuffer());
status = STATUS_SUCCESS;
}
break;
}
///////////////////////////////////////////////////////////////////
// Get Timeouts
//(20h--8)
case IOCTL_SERIAL_GET_TIMEOUTS:
{
t <<"GetTIMEOUT" << EOL;
if (I.IoctlOutputBufferSize() < sizeof(SERIAL_TIMEOUTS) )
return STATUS_BUFFER_TOO_SMALL;
else
{
IoctlGetTimeOuts( *(SERIAL_TIMEOUTS*)I.IoctlBuffer());
I.Information() = sizeof(SERIAL_TIMEOUTS);
status = STATUS_SUCCESS;
SERIAL_TIMEOUTS* p=(SERIAL_TIMEOUTS*)I.IoctlBuffer();
}
break;
}
#if NTVERSION > 351
///////////////////////////////////////////////////////////////////
// Get Statistics
//
case IOCTL_SERIAL_GET_STATS:
t <<"GetSTAT" << EOL;
if (I.IoctlOutputBufferSize() < sizeof (SERIALPERF_STATS) )
status = STATUS_BUFFER_TOO_SMALL;
else
{
IoctlGetStatistics(*(SERIALPERF_STATS*)I.IoctlBuffer());
I.Information() = sizeof(SERIALPERF_STATS);
status = STATUS_SUCCESS;
}
break;
#endif
#if NTVERSION > 351
///////////////////////////////////////////////////////////////////
// Clear Statistics
//
case IOCTL_SERIAL_CLEAR_STATS:
t <<"CLRSTATS" << EOL;
IoctlClearStatistics();
status = STATUS_SUCCESS;
break;
#endif
///////////////////////////////////////////////////////////////////
// Get Wait Mask
//(40h--16)
case IOCTL_SERIAL_GET_WAIT_MASK:
t <<"GetWAITMASK" << EOL;
if (I.IoctlOutputBufferSize() < sizeof(ULONG) )
status = STATUS_BUFFER_TOO_SMALL;
else
{
*(ULONG*)I.IoctlBuffer() = IoctlGetWaitMask();
I.Information() = sizeof(ULONG);
status = STATUS_SUCCESS;
}
break;
///////////////////////////////////////////////////////////////////
// Set Wait Mask
//(44h--11)
case IOCTL_SERIAL_SET_WAIT_MASK:
// GTRACE((TLEVEL,"--IOCTL_SERIAL_SET_WAIT_MASK\n"));
// GTRACE((TLEVEL,"Set wait mask to %x\n", *(ULONG*)I.IoctlBuffer()));
// if (I.IoctlInputBufferSize() < sizeof(ULONG) )
// status = STATUS_BUFFER_TOO_SMALL;
// else if ( ~m_SupportedEvents & *(ULONG*)I.IoctlBuffer() )
// status = STATUS_INVALID_PARAMETER;
// else
// status = m_WaitIrpQueue.QueueIrp(I);
// status = STATUS_SUCCESS;
m_WaitMask = *(ULONG*)I.IoctlBuffer();
// t << "Set Mask" << m_WaitMask<<EOL;
// I.SetCancelRoutine(NULL);
// m_Device->StartSetMask(Mask);
// I.Status() = STATUS_SUCCESS;
I.Information() = 0;
status = STATUS_SUCCESS;
break;
///////////////////////////////////////////////////////////////////
// Wait on Mask
//(48h--18)
case IOCTL_SERIAL_WAIT_ON_MASK:
// GTRACE((TLEVEL,"--IOCTL_SERIAL_WAIT_ON_MASK\n"));
// if (I.IoctlOutputBufferSize() < sizeof(ULONG) )
// status = STATUS_BUFFER_TOO_SMALL;
// else if (m_WaitMask == 0)
// status = STATUS_INVALID_PARAMETER;
// else
// status = m_WaitIrpQueue.QueueIrp(I);
if((m_Unit&1)==0){
*(ULONG*)I.IoctlBuffer()=(ULONG)m_pRW->MaskB;
// if((ULONG)m_pRW->MaskB==1)
// t<<"Wait on MaskB:"<<(ULONG)m_pRW->MaskB<<EOL;
}else{
*(ULONG*)I.IoctlBuffer()=(ULONG)m_pRW->MaskA;
// if((ULONG)m_pRW->MaskA==1)
// t<<"Wait on MaskA:"<<(ULONG)m_pRW->MaskA<<EOL;
}
// *(ULONG*)I.IoctlBuffer()=(ULONG)m_EvenMask;
I.Information() = sizeof( ULONG );
// t << "Wait on Mask" << m_EvenMask<<EOL;
status = STATUS_SUCCESS;
break;
///////////////////////////////////////////////////////////////////
// Get Properties
//(74h--29)
case IOCTL_SERIAL_GET_PROPERTIES:
t <<"GetProperties" << EOL;
if (I.IoctlOutputBufferSize() < sizeof(SERIAL_COMMPROP) )
status = STATUS_BUFFER_TOO_SMALL;
else
{
IoctlGetProperties(*(SERIAL_COMMPROP*)I.IoctlBuffer());
I.Information() = sizeof(SERIAL_COMMPROP);
status = STATUS_SUCCESS;
}
break;
///////////////////////////////////////////////////////////////////
// Get Modem Status
//
case IOCTL_SERIAL_GET_MODEMSTATUS:
t <<"GetModemStatus" << EOL;
if (I.IoctlOutputBufferSize() < sizeof(ULONG) )
status = STATUS_BUFFER_TOO_SMALL;
else
{
*(ULONG*)I.IoctlBuffer() = IoctlGetModemStatus();
I.Information() = sizeof(ULONG);
status = STATUS_SUCCESS;
}
break;
///////////////////////////////////////////////////////////////////
// Get Comm Status
//(6ch--27)
case IOCTL_SERIAL_GET_COMMSTATUS:
if (I.IoctlOutputBufferSize() < sizeof(SERIAL_STATUS) )
status = STATUS_BUFFER_TOO_SMALL;
else
{
IoctlGetCommStatus(*(SERIAL_STATUS*)I.IoctlBuffer());
I.Information() = sizeof(SERIAL_STATUS);
status = STATUS_SUCCESS;
}
break;
///////////////////////////////////////////////////////////////////
// Purge
//
case IOCTL_SERIAL_PURGE:
t <<"Purge" << EOL;
// GTRACE((TLEVEL,"--IOCTL_SERIAL_PURGE\n"));
if (I.IoctlInputBufferSize() < sizeof(ULONG) )
status = STATUS_BUFFER_TOO_SMALL;
else if ( *(ULONG*)I.IoctlBuffer() & ~VALID_PURGE_MASK )
status = STATUS_INVALID_PARAMETER;
else
{
IoctlPurge(*(ULONG*)I.IoctlBuffer());
I.Information() = 0;
status = STATUS_SUCCESS;
}
break;
///////////////////////////////////////////////////////////////////
// SetQueueSize
//
case IOCTL_SERIAL_SET_QUEUE_SIZE:
t <<"SetQueueSize" << EOL;
if (I.IoctlInputBufferSize() < sizeof(SERIAL_QUEUE_SIZE) )
status = STATUS_BUFFER_TOO_SMALL;
else
status = IoctlSetQueueSize(*(SERIAL_QUEUE_SIZE*)I.IoctlBuffer());
break;
///////////////////////////////////////////////////////////////////
// GetConfigSize
//
case IOCTL_SERIAL_CONFIG_SIZE:
t <<"ConfigSize" << EOL;
if (I.IoctlOutputBufferSize() < sizeof(ULONG) )
status = STATUS_BUFFER_TOO_SMALL;
else
{
*(ULONG*)I.IoctlBuffer() = 0;
I.Information() = sizeof(ULONG);
status = STATUS_SUCCESS;
}
break;
//----------
case IOCTL_SERIAL_SET_BREAK_OFF:
t <<"SetBreakOff" << EOL;
status = STATUS_SUCCESS; // required by HCT
break;
case IOCTL_SERIAL_XOFF_COUNTER:
case IOCTL_SERIAL_GET_COMMCONFIG:
case IOCTL_SERIAL_SET_COMMCONFIG:
case IOCTL_SERIAL_SET_BREAK_ON:
case IOCTL_SERIAL_IMMEDIATE_CHAR:
case IOCTL_SERIAL_SET_XOFF:
case IOCTL_SERIAL_SET_XON:
case IOCTL_SERIAL_GET_DTRRTS:
case IOCTL_SERIAL_LSRMST_INSERT:
// GTRACE( (TLEVEL, "Unsupported Ioctl code=%x\n", I.IoctlCode()));
status = STATUS_INVALID_PARAMETER;
break;
default:
// GTRACE( (TLEVEL, "Unknown Ioctl code=%x\n", I.IoctlCode()));
status = STATUS_INVALID_PARAMETER;
break;
}
// If the IRP's IOCTL handler deferred processing using some driver
// specific scheme, the status variable is set to STATUS_PENDING.
// In this case we simply return that status, and the IRP will be
// completed later. Otherwise, complete the IRP using the status
// returned by the IOCTL handler.
CancelSpinLock::Release();
if (status == STATUS_PENDING)
{
return status;
}
else
{
return I.Complete(status);
}
}
/////////////////////////////////////////////////////////////////
// IoctlGetBaudRate
//
// Get the current baud rate
//
VOID ComfilntDevice::IoctlGetBaudRate(SERIAL_BAUD_RATE& BaudRate)
{
BaudRate = m_BaudRate;
}
/////////////////////////////////////////////////////////////////
// IoctlSetHandFlow
//
// Set handshake and flow control parameters
//
NTSTATUS ComfilntDevice::IoctlSetHandFlow(SERIAL_HANDFLOW& HandFlow)
{
m_Handflow = HandFlow;
return STATUS_SUCCESS;
}
/////////////////////////////////////////////////////////////////
// IoctlGetTimeOuts
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -