You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2920 lines
79 KiB
2920 lines
79 KiB
/*****************************************************************************
|
|
*
|
|
* Copyright (c) 1996-1999 Microsoft Corporation
|
|
*
|
|
* @doc
|
|
* @module ioctl.c | IrSIR NDIS Miniport Driver
|
|
* @comm
|
|
*
|
|
*-----------------------------------------------------------------------------
|
|
*
|
|
* Author: Scott Holden (sholden)
|
|
*
|
|
* Date: 9/30/1996 (created)
|
|
*
|
|
* Contents:
|
|
* Wrappers to the io control functions of the serial port.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
|
|
#include "irsir.h"
|
|
|
|
NTSTATUS
|
|
SerialFlush(IN PDEVICE_OBJECT pSerialDevObj);
|
|
|
|
|
|
VOID
|
|
SendIoctlToSerial(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIO_STATUS_BLOCK StatusBlock,
|
|
ULONG IoCtl,
|
|
PVOID InputBuffer,
|
|
ULONG InputBufferLength,
|
|
PVOID OutputBuffer,
|
|
ULONG OutputBufferLength
|
|
);
|
|
|
|
#pragma alloc_text(PAGE, SendIoctlToSerial)
|
|
#pragma alloc_text(PAGE, SerialGetStats)
|
|
#pragma alloc_text(PAGE, SerialClearStats)
|
|
#pragma alloc_text(PAGE, SerialGetProperties)
|
|
#pragma alloc_text(PAGE, SerialGetModemStatus)
|
|
#pragma alloc_text(PAGE, SerialGetCommStatus)
|
|
#pragma alloc_text(PAGE, SerialResetDevice)
|
|
#pragma alloc_text(PAGE, SerialPurge)
|
|
#pragma alloc_text(PAGE, SerialLSRMSTInsert)
|
|
#pragma alloc_text(PAGE, SerialGetBaudRate)
|
|
#pragma alloc_text(PAGE, SerialSetBaudRate)
|
|
#pragma alloc_text(PAGE, SerialSetQueueSize)
|
|
#pragma alloc_text(PAGE, SerialGetHandflow)
|
|
#pragma alloc_text(PAGE, SerialSetHandflow)
|
|
#pragma alloc_text(PAGE, SerialGetLineControl)
|
|
#pragma alloc_text(PAGE, SerialSetLineControl)
|
|
#pragma alloc_text(PAGE, SerialSetBreakOn)
|
|
#pragma alloc_text(PAGE, SerialSetBreakOff)
|
|
#pragma alloc_text(PAGE, SerialSetTimeouts)
|
|
#pragma alloc_text(PAGE, SerialSetDTR)
|
|
#pragma alloc_text(PAGE, SerialClrDTR)
|
|
#pragma alloc_text(PAGE, SerialSetRTS)
|
|
#pragma alloc_text(PAGE, SerialClrRTS)
|
|
#pragma alloc_text(PAGE, SerialSetWaitMask)
|
|
#pragma alloc_text(PAGE, SerialFlush)
|
|
#pragma alloc_text(PAGE, SerialSynchronousWrite)
|
|
#pragma alloc_text(PAGE, SerialSynchronousRead)
|
|
|
|
//
|
|
// NOTE:
|
|
// all IOCTL_SERIAL_xxx control codes are built using the CTL_CODE macro
|
|
// i.e. #define IOCTL_SERIAL_GET_BAUD_RATE \
|
|
// CTL_CODE( FILE_DEVICE_SERIAL_PORT, \
|
|
// 20, \
|
|
// METHOD_BUFFERED, \
|
|
// FILE_ANY_ACCESS)
|
|
//
|
|
// the CTL_CODE macro is defined as:
|
|
// #define CTL_CODE( DeviceType, Function, Method, Access ) \
|
|
// ( ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) )
|
|
//
|
|
// all of the serial io control codes use Method = METHOD_BUFFERED
|
|
//
|
|
// when using the IoBuildDeviceIoControlRequest(..), the function checks
|
|
// IOCTL_SERIAL_xxx & 3
|
|
//
|
|
// since METHOD_BUFFERED = 0
|
|
// IoBuildDeviceIoControlRequest will always follow case 0 and allocate a buffer
|
|
// which is large enough to contain both the input and output buffers and then
|
|
// set the appropriate fields in the irp.
|
|
//
|
|
// the input buffer is always copied into the buffer, so we don't have to do
|
|
// it in the following wrapper functions
|
|
//
|
|
|
|
VOID
|
|
SendIoctlToSerial(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIO_STATUS_BLOCK StatusBlock,
|
|
ULONG IoCtl,
|
|
PVOID InputBuffer,
|
|
ULONG InputBufferLength,
|
|
PVOID OutputBuffer,
|
|
ULONG OutputBufferLength
|
|
)
|
|
|
|
{
|
|
KEVENT Event;
|
|
PIRP Irp;
|
|
NTSTATUS Status;
|
|
|
|
PAGED_CODE();
|
|
|
|
if (DeviceObject == NULL) {
|
|
|
|
DEBUGMSG(DBG_OUT, (" SendIoctlToSerial() No device object.\n"));
|
|
|
|
StatusBlock->Status=STATUS_INVALID_PARAMETER;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
//
|
|
// event to wait for completion of serial driver
|
|
//
|
|
|
|
KeInitializeEvent(
|
|
&Event,
|
|
NotificationEvent,
|
|
FALSE
|
|
);
|
|
|
|
//
|
|
// build irp to get performance stats and wait for event signalled
|
|
//
|
|
// irp is released by io manager
|
|
//
|
|
|
|
Irp = IoBuildDeviceIoControlRequest(
|
|
IoCtl, // io control code
|
|
DeviceObject, // device object
|
|
InputBuffer, // input buffer
|
|
InputBufferLength, // input buffer length
|
|
OutputBuffer, // output buffer
|
|
OutputBufferLength, // output buffer length
|
|
FALSE, // calls IRP_MJ_DEVICE_CONTROL rather than IRP_MJ_INTERNAL_DEVICE_CONTROL
|
|
&Event, // event to wait for completion
|
|
StatusBlock // io status block to be set
|
|
);
|
|
|
|
if (Irp == NULL) {
|
|
|
|
DEBUGMSG(DBG_OUT, (" SendIoctlToSerial(): IoBuildDeviceIoControlRequest failed.\n"));
|
|
StatusBlock->Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
return;
|
|
}
|
|
|
|
Status = IoCallDriver(DeviceObject, Irp);
|
|
|
|
//
|
|
// if IoCallDriver returns STATUS_PENDING, we need to wait for the event
|
|
//
|
|
|
|
if (Status == STATUS_PENDING) {
|
|
|
|
KeWaitForSingleObject(
|
|
&Event, // object to wait for
|
|
Executive, // reason to wait
|
|
KernelMode, // processor mode
|
|
FALSE, // alertable
|
|
NULL // timeout
|
|
);
|
|
|
|
//
|
|
// we can get the status of the IoCallDriver from the io status
|
|
// block
|
|
//
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialGetStats
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialGetStats(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
OUT PSERIALPERF_STATS pPerfStats
|
|
)
|
|
{
|
|
SERIALPERF_STATS PerfStats;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialGetStats\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_GET_STATS,
|
|
NULL,
|
|
0,
|
|
&PerfStats, // output buffer
|
|
sizeof(SERIALPERF_STATS) // output buffer length
|
|
);
|
|
|
|
ASSERT(sizeof(*pPerfStats) >= sizeof(SERIALPERF_STATS));
|
|
|
|
if (NT_SUCCESS(ioStatusBlock.Status)) {
|
|
|
|
RtlCopyMemory(pPerfStats, &PerfStats, sizeof(SERIALPERF_STATS));
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialGetStats\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialClearStats
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialClearStats(
|
|
IN PDEVICE_OBJECT pSerialDevObj
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialClearStats\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_CLEAR_STATS,
|
|
NULL,
|
|
0,
|
|
NULL, // output buffer
|
|
0 // output buffer length
|
|
);
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialClearStats\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialGetProperties
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialGetProperties(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
OUT PSERIAL_COMMPROP pCommProp
|
|
)
|
|
{
|
|
SERIAL_COMMPROP CommProp;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialGetProperties\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_GET_PROPERTIES,
|
|
NULL,
|
|
0,
|
|
&CommProp, // output buffer
|
|
sizeof(SERIAL_COMMPROP) // output buffer length
|
|
);
|
|
|
|
ASSERT(sizeof(*pCommProp) >= sizeof(SERIAL_COMMPROP));
|
|
|
|
if (NT_SUCCESS(ioStatusBlock.Status)) {
|
|
|
|
RtlCopyMemory(pCommProp, &CommProp, sizeof(SERIAL_COMMPROP));
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialGetProperties\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialGetModemStatus
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialGetModemStatus(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
OUT ULONG *pModemStatus
|
|
)
|
|
{
|
|
ULONG ModemStatus;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialGetModemStatus\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_GET_MODEMSTATUS,
|
|
NULL,
|
|
0,
|
|
&ModemStatus, // output buffer
|
|
sizeof(ULONG) // output buffer length
|
|
);
|
|
|
|
ASSERT(sizeof(*pModemStatus) >= sizeof(ULONG));
|
|
|
|
if (NT_SUCCESS(ioStatusBlock.Status)) {
|
|
|
|
RtlCopyMemory(pModemStatus, &ModemStatus, sizeof(ULONG));
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialGetModemStatus\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialGetCommStatus
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialGetCommStatus(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
OUT PSERIAL_STATUS pCommStatus
|
|
)
|
|
{
|
|
SERIAL_STATUS CommStatus;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialGetCommStatus\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_GET_COMMSTATUS,
|
|
NULL,
|
|
0,
|
|
&CommStatus, // output buffer
|
|
sizeof(SERIAL_STATUS) // output buffer length
|
|
);
|
|
|
|
ASSERT(sizeof(*pCommStatus) >= sizeof(SERIAL_STATUS));
|
|
|
|
if (NT_SUCCESS(ioStatusBlock.Status)) {
|
|
|
|
RtlCopyMemory(pCommStatus, &CommStatus, sizeof(SERIAL_STATUS));
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialGetCommStatus\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialResetDevice
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialResetDevice(
|
|
IN PDEVICE_OBJECT pSerialDevObj
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialResetDevice\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_RESET_DEVICE,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialResetDevice\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialPurge
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialPurge(
|
|
IN PDEVICE_OBJECT pSerialDevObj
|
|
)
|
|
{
|
|
ULONG BitMask;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialPurge\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_PURGE,
|
|
&BitMask, // input buffer
|
|
sizeof(ULONG), // input buffer length
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialPurge\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
|
|
}
|
|
#if 0
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialLSRMSTInsert
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialLSRMSTInsert(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
IN UCHAR *pInsertionMode
|
|
)
|
|
{
|
|
UCHAR InsertionMode;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialLSRMSTInsert\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_LSRMST_INSERT,
|
|
pInsertionMode, // input buffer
|
|
sizeof(UCHAR), // input buffer length
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialLSRMSTInsert\n"));
|
|
|
|
return IoStatusBlock.Status;
|
|
|
|
}
|
|
#endif
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialGetBaudRate
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialGetBaudRate(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
OUT ULONG *pBaudRate
|
|
)
|
|
{
|
|
ULONG BaudRate;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialGetBaudRate\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_GET_BAUD_RATE, // io control code
|
|
NULL,
|
|
0,
|
|
&BaudRate, // output buffer
|
|
sizeof(ULONG) // output buffer length
|
|
);
|
|
|
|
ASSERT(sizeof(*pBaudRate) >= sizeof(ULONG));
|
|
|
|
if (NT_SUCCESS(ioStatusBlock.Status)) {
|
|
|
|
RtlCopyMemory(pBaudRate, &BaudRate, sizeof(ULONG));
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialGetBaudRate\n"));
|
|
|
|
|
|
return ioStatusBlock.Status;
|
|
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialSetBaudRate
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialSetBaudRate(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
IN ULONG *pBaudRate
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialSetBaudRate\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_SET_BAUD_RATE, // io control code
|
|
pBaudRate, // input buffer
|
|
sizeof(ULONG), // input buffer length
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialSetBaudRate\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialSetQueueSize
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialSetQueueSize(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
IN PSERIAL_QUEUE_SIZE pQueueSize
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialSetQueueSize\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_SET_QUEUE_SIZE, // io control code
|
|
pQueueSize, // input buffer
|
|
sizeof(SERIAL_QUEUE_SIZE), // input buffer length
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialSetQueueSize\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
|
|
}
|
|
#if 0
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialGetHandflow
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialGetHandflow(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
OUT PSERIAL_HANDFLOW pHandflow
|
|
)
|
|
{
|
|
SERIAL_HANDFLOW Handflow;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialGetHandflow\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_GET_HANDFLOW, // io control code
|
|
NULL,
|
|
0,
|
|
&Handflow, // output buffer
|
|
sizeof(SERIAL_HANDFLOW), // output buffer length
|
|
);
|
|
|
|
ASSERT(sizeof(*pHandflow) >= sizeof(SERIAL_HANDFLOW));
|
|
|
|
RtlCopyMemory(pHandflow, &Handflow, sizeof(SERIAL_HANDFLOW));
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialGetHandflow\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialSetHandflow
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialSetHandflow(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
IN PSERIAL_HANDFLOW pHandflow
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialSetHandflow\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_SET_HANDFLOW, // io control code
|
|
pHandflow, // input buffer
|
|
sizeof(SERIAL_HANDFLOW), // input buffer length
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialSetHandflow\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
|
|
}
|
|
#endif
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialGetLineControl
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialGetLineControl(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
OUT PSERIAL_LINE_CONTROL pLineControl
|
|
)
|
|
{
|
|
SERIAL_LINE_CONTROL LineControl;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialGetLineControl\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_GET_LINE_CONTROL,
|
|
NULL,
|
|
0,
|
|
&LineControl, // output buffer
|
|
sizeof(SERIAL_LINE_CONTROL) // output buffer length
|
|
);
|
|
|
|
|
|
ASSERT(sizeof(*pLineControl) >= sizeof(SERIAL_LINE_CONTROL));
|
|
|
|
if (NT_SUCCESS(ioStatusBlock.Status)) {
|
|
|
|
RtlCopyMemory(pLineControl, &LineControl, sizeof(SERIAL_LINE_CONTROL));
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialGetLineControl\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialSetLineControl
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialSetLineControl(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
IN PSERIAL_LINE_CONTROL pLineControl
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialSetLineControl\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_SET_LINE_CONTROL, // io control code
|
|
pLineControl, // input buffer
|
|
sizeof(SERIAL_LINE_CONTROL), // input buffer length
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialResetDevice\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialSetBreakOn
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialSetBreakOn(
|
|
IN PDEVICE_OBJECT pSerialDevObj
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialSetBreakOn\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_SET_BREAK_ON, // io control code
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialSetBreakOn\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
|
|
}
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialSetBreakOff
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialSetBreakOff(
|
|
IN PDEVICE_OBJECT pSerialDevObj
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialSetBreakOff\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_SET_BREAK_OFF, // io control code
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialSetBreakOff\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
|
|
}
|
|
#if 0
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialGetTimeouts
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialGetTimeouts(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
OUT PSERIAL_TIMEOUTS pTimeouts
|
|
)
|
|
{
|
|
PIRP pIrp;
|
|
SERIAL_TIMEOUTS Timeouts;
|
|
KEVENT eventComplete;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
NTSTATUS status;
|
|
|
|
|
|
if (!pSerialDevObj)
|
|
{
|
|
DEBUGMSG(DBG_ERROR, ("IRSIR: SerialDevObj==NULL\n"));
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialGetTimeouts\n"));
|
|
|
|
//
|
|
// event to wait for completion of serial driver
|
|
//
|
|
|
|
KeInitializeEvent(
|
|
&eventComplete,
|
|
NotificationEvent,
|
|
FALSE
|
|
);
|
|
|
|
//
|
|
// build irp to get baud rate and wait for event signalled
|
|
//
|
|
// irp is released by io manager
|
|
//
|
|
|
|
pIrp = IoBuildDeviceIoControlRequest(
|
|
IOCTL_SERIAL_GET_TIMEOUTS, // io control code
|
|
pSerialDevObj, // device object
|
|
NULL, // input buffer
|
|
0, // input buffer length
|
|
&Timeouts, // output buffer
|
|
sizeof(SERIAL_TIMEOUTS), // output buffer length
|
|
FALSE, // calls IRP_MJ_DEVICE_CONTROL
|
|
// rather than IRP_MJ_INTERNAL_DEVICE_CONTROL
|
|
&eventComplete, // event to wait for completion
|
|
&ioStatusBlock // io status block to be set
|
|
);
|
|
|
|
if (pIrp == NULL)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoBuildDeviceIoControlRequest() failed.\n"));
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
goto done;
|
|
}
|
|
|
|
status = IoCallDriver(pSerialDevObj, pIrp);
|
|
|
|
//
|
|
// if IoCallDriver returns STATUS_PENDING, we need to wait for the event
|
|
//
|
|
|
|
if (status == STATUS_PENDING)
|
|
{
|
|
KeWaitForSingleObject(
|
|
&eventComplete, // object to wait for
|
|
Executive, // reason to wait
|
|
KernelMode, // processor mode
|
|
FALSE, // alertable
|
|
NULL // timeout
|
|
);
|
|
|
|
//
|
|
// we can get the status of the IoCallDriver from the io status
|
|
// block
|
|
//
|
|
|
|
status = ioStatusBlock.Status;
|
|
}
|
|
|
|
//
|
|
// if IoCallDriver returns something other that STATUS_PENDING, then it
|
|
// is the same as what the serial driver set in ioStatusBlock.Status
|
|
//
|
|
|
|
if (status != STATUS_SUCCESS)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoCallDriver() failed. Returned = 0x%.8x\n", status));
|
|
|
|
goto done;
|
|
}
|
|
|
|
ASSERT(sizeof(*pTimeouts) >= sizeof(SERIAL_TIMEOUTS));
|
|
|
|
RtlCopyMemory(pTimeouts, &Timeouts, sizeof(SERIAL_TIMEOUTS));
|
|
|
|
done:
|
|
DEBUGMSG(DBG_FUNC, ("-SerialGetTimeouts\n"));
|
|
return status;
|
|
}
|
|
#endif
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialSetTimeouts
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialSetTimeouts(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
IN SERIAL_TIMEOUTS *pTimeouts
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialSetTimeouts\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_SET_TIMEOUTS, // io control code
|
|
pTimeouts, // input buffer
|
|
sizeof(SERIAL_TIMEOUTS), // input buffer length
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialSetTimeouts\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
}
|
|
#if 0
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialImmediateChar
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialImmediateChar(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
IN UCHAR *pImmediateChar
|
|
)
|
|
{
|
|
PIRP pIrp;
|
|
KEVENT eventComplete;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
if (!pSerialDevObj)
|
|
{
|
|
DEBUGMSG(DBG_ERROR, ("IRSIR: SerialDevObj==NULL\n"));
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialImmediateChar\n"));
|
|
|
|
//
|
|
// event to wait for completion of serial driver
|
|
//
|
|
|
|
KeInitializeEvent(
|
|
&eventComplete,
|
|
NotificationEvent,
|
|
FALSE
|
|
);
|
|
|
|
//
|
|
// build irp to set baud rate and wait for event signalled
|
|
//
|
|
// irp is released by io manager
|
|
//
|
|
|
|
pIrp = IoBuildDeviceIoControlRequest(
|
|
IOCTL_SERIAL_IMMEDIATE_CHAR, // io control code
|
|
pSerialDevObj, // device object
|
|
pImmediateChar, // input buffer
|
|
sizeof(UCHAR), // input buffer length
|
|
NULL, // output buffer
|
|
0, // output buffer length
|
|
FALSE, // calls IRP_MJ_DEVICE_CONTROL
|
|
// rather than IRP_MJ_INTERNAL_DEVICE_CONTROL
|
|
&eventComplete, // event to wait for completion
|
|
&ioStatusBlock // io status block to be set
|
|
);
|
|
|
|
if (pIrp == NULL)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoBuildDeviceIoControlRequest() failed.\n"));
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
goto done;
|
|
}
|
|
|
|
status = IoCallDriver(pSerialDevObj, pIrp);
|
|
|
|
//
|
|
// if IoCallDriver returns STATUS_PENDING, we need to wait for the event
|
|
//
|
|
|
|
if (status == STATUS_PENDING)
|
|
{
|
|
KeWaitForSingleObject(
|
|
&eventComplete, // object to wait for
|
|
Executive, // reason to wait
|
|
KernelMode, // processor mode
|
|
FALSE, // alertable
|
|
NULL // timeout
|
|
);
|
|
|
|
//
|
|
// we can get the status of the IoCallDriver from the io status
|
|
// block
|
|
//
|
|
|
|
status = ioStatusBlock.Status;
|
|
}
|
|
|
|
//
|
|
// if IoCallDriver returns something other that STATUS_PENDING, then it
|
|
// is the same as what the serial driver set in ioStatusBlock.Status
|
|
//
|
|
|
|
if (status != STATUS_SUCCESS)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoCallDriver() failed. Returned = 0x%.8x\n", status));
|
|
|
|
goto done;
|
|
}
|
|
|
|
done:
|
|
DEBUGMSG(DBG_FUNC, ("-SerialImmediateChar\n"));
|
|
return status;
|
|
}
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialXoffCounter
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
NTSTATUS
|
|
SerialXoffCounter(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
IN PSERIAL_XOFF_COUNTER pXoffCounter
|
|
)
|
|
{
|
|
PIRP pIrp;
|
|
KEVENT eventComplete;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
NTSTATUS status;
|
|
|
|
|
|
if (!pSerialDevObj)
|
|
{
|
|
DEBUGMSG(DBG_ERROR, ("IRSIR: SerialDevObj==NULL\n"));
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialXoffCounter\n"));
|
|
|
|
//
|
|
// event to wait for completion of serial driver
|
|
//
|
|
|
|
KeInitializeEvent(
|
|
&eventComplete,
|
|
NotificationEvent,
|
|
FALSE
|
|
);
|
|
|
|
//
|
|
// build irp to set baud rate and wait for event signalled
|
|
//
|
|
// irp is released by io manager
|
|
//
|
|
|
|
pIrp = IoBuildDeviceIoControlRequest(
|
|
IOCTL_SERIAL_XOFF_COUNTER, // io control code
|
|
pSerialDevObj, // device object
|
|
pXoffCounter, // input buffer
|
|
sizeof(SERIAL_XOFF_COUNTER), // input buffer length
|
|
NULL, // output buffer
|
|
0, // output buffer length
|
|
FALSE, // calls IRP_MJ_DEVICE_CONTROL
|
|
// rather than IRP_MJ_INTERNAL_DEVICE_CONTROL
|
|
&eventComplete, // event to wait for completion
|
|
&ioStatusBlock // io status block to be set
|
|
);
|
|
|
|
if (pIrp == NULL)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoBuildDeviceIoControlRequest() failed.\n"));
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
goto done;
|
|
}
|
|
|
|
status = IoCallDriver(pSerialDevObj, pIrp);
|
|
|
|
//
|
|
// if IoCallDriver returns STATUS_PENDING, we need to wait for the event
|
|
//
|
|
|
|
if (status == STATUS_PENDING)
|
|
{
|
|
KeWaitForSingleObject(
|
|
&eventComplete, // object to wait for
|
|
Executive, // reason to wait
|
|
KernelMode, // processor mode
|
|
FALSE, // alertable
|
|
NULL // timeout
|
|
);
|
|
|
|
//
|
|
// we can get the status of the IoCallDriver from the io status
|
|
// block
|
|
//
|
|
|
|
status = ioStatusBlock.Status;
|
|
}
|
|
|
|
//
|
|
// if IoCallDriver returns something other that STATUS_PENDING, then it
|
|
// is the same as what the serial driver set in ioStatusBlock.Status
|
|
//
|
|
|
|
if (status != STATUS_SUCCESS)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoCallDriver() failed. Returned = 0x%.8x\n", status));
|
|
|
|
goto done;
|
|
}
|
|
|
|
done:
|
|
DEBUGMSG(DBG_FUNC, ("-SerialXoffCounter\n"));
|
|
return status;
|
|
}
|
|
#endif
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialSetDTR
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialSetDTR(
|
|
IN PDEVICE_OBJECT pSerialDevObj
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialSetDTR\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_SET_DTR, // io control code
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialSetDTR\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialClrDTR
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialClrDTR(
|
|
IN PDEVICE_OBJECT pSerialDevObj
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialClrDTR\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_CLR_DTR, // io control code
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialClrDTR\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialSetRTS
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialSetRTS(
|
|
IN PDEVICE_OBJECT pSerialDevObj
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialSetRTS\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_SET_RTS, // io control code
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialSetRTS\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialClrRTS
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialClrRTS(
|
|
IN PDEVICE_OBJECT pSerialDevObj
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialClrRTS\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_CLR_RTS, // io control code
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialClrRTS\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
}
|
|
#if 0
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialGetDtrRts
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialGetDtrRts(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
OUT ULONG *pDtrRts
|
|
)
|
|
{
|
|
PIRP pIrp;
|
|
ULONG DtrRts;
|
|
KEVENT eventComplete;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
NTSTATUS status;
|
|
|
|
|
|
if (!pSerialDevObj)
|
|
{
|
|
DEBUGMSG(DBG_ERROR, ("IRSIR: SerialDevObj==NULL\n"));
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialGetDtrRts\n"));
|
|
|
|
//
|
|
// event to wait for completion of serial driver
|
|
//
|
|
|
|
KeInitializeEvent(
|
|
&eventComplete,
|
|
NotificationEvent,
|
|
FALSE
|
|
);
|
|
|
|
//
|
|
// build irp to get baud rate and wait for event signalled
|
|
//
|
|
// irp is released by io manager
|
|
//
|
|
|
|
pIrp = IoBuildDeviceIoControlRequest(
|
|
IOCTL_SERIAL_GET_DTRRTS, // io control code
|
|
pSerialDevObj, // device object
|
|
NULL, // input buffer
|
|
0, // input buffer length
|
|
&DtrRts, // output buffer
|
|
sizeof(ULONG), // output buffer length
|
|
FALSE, // calls IRP_MJ_DEVICE_CONTROL
|
|
// rather than IRP_MJ_INTERNAL_DEVICE_CONTROL
|
|
&eventComplete, // event to wait for completion
|
|
&ioStatusBlock // io status block to be set
|
|
);
|
|
|
|
if (pIrp == NULL)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoBuildDeviceIoControlRequest() failed.\n"));
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
goto done;
|
|
}
|
|
|
|
status = IoCallDriver(pSerialDevObj, pIrp);
|
|
|
|
//
|
|
// if IoCallDriver returns STATUS_PENDING, we need to wait for the event
|
|
//
|
|
|
|
if (status == STATUS_PENDING)
|
|
{
|
|
KeWaitForSingleObject(
|
|
&eventComplete, // object to wait for
|
|
Executive, // reason to wait
|
|
KernelMode, // processor mode
|
|
FALSE, // alertable
|
|
NULL // timeout
|
|
);
|
|
|
|
//
|
|
// we can get the status of the IoCallDriver from the io status
|
|
// block
|
|
//
|
|
|
|
status = ioStatusBlock.Status;
|
|
}
|
|
|
|
//
|
|
// if IoCallDriver returns something other that STATUS_PENDING, then it
|
|
// is the same as what the serial driver set in ioStatusBlock.Status
|
|
//
|
|
|
|
if (status != STATUS_SUCCESS)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoCallDriver() failed. Returned = 0x%.8x\n", status));
|
|
|
|
goto done;
|
|
}
|
|
|
|
ASSERT(sizeof(*pDtrRts) >= sizeof(ULONG));
|
|
|
|
RtlCopyMemory(pDtrRts, &DtrRts, sizeof(ULONG));
|
|
|
|
done:
|
|
DEBUGMSG(DBG_FUNC, ("-SerialGetDtrRts\n"));
|
|
return status;
|
|
}
|
|
#endif
|
|
#if 0
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialSetXon
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialSetXon(
|
|
IN PDEVICE_OBJECT pSerialDevObj
|
|
)
|
|
{
|
|
PIRP pIrp;
|
|
KEVENT eventComplete;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
NTSTATUS status;
|
|
|
|
|
|
if (!pSerialDevObj)
|
|
{
|
|
DEBUGMSG(DBG_ERROR, ("IRSIR: SerialDevObj==NULL\n"));
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialSetXon\n"));
|
|
|
|
//
|
|
// event to wait for completion of serial driver
|
|
//
|
|
|
|
KeInitializeEvent(
|
|
&eventComplete,
|
|
NotificationEvent,
|
|
FALSE
|
|
);
|
|
|
|
//
|
|
// build irp to set Xon and wait for event signalled
|
|
//
|
|
// irp is released by io manager
|
|
//
|
|
|
|
pIrp = IoBuildDeviceIoControlRequest(
|
|
IOCTL_SERIAL_SET_XON, // io control code
|
|
pSerialDevObj, // device object
|
|
NULL, // input buffer
|
|
0, // input buffer length
|
|
NULL, // output buffer
|
|
0, // output buffer length
|
|
FALSE, // calls IRP_MJ_DEVICE_CONTROL
|
|
// rather than IRP_MJ_INTERNAL_DEVICE_CONTROL
|
|
&eventComplete, // event to wait for completion
|
|
&ioStatusBlock // io status block to be set
|
|
);
|
|
|
|
if (pIrp == NULL)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoBuildDeviceIoControlRequest() failed.\n"));
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
goto done;
|
|
}
|
|
|
|
status = IoCallDriver(pSerialDevObj, pIrp);
|
|
|
|
//
|
|
// if IoCallDriver returns STATUS_PENDING, we need to wait for the event
|
|
//
|
|
|
|
if (status == STATUS_PENDING)
|
|
{
|
|
KeWaitForSingleObject(
|
|
&eventComplete, // object to wait for
|
|
Executive, // reason to wait
|
|
KernelMode, // processor mode
|
|
FALSE, // alertable
|
|
NULL // timeout
|
|
);
|
|
|
|
//
|
|
// we can get the status of the IoCallDriver from the io status
|
|
// block
|
|
//
|
|
|
|
status = ioStatusBlock.Status;
|
|
}
|
|
|
|
//
|
|
// if IoCallDriver returns something other that STATUS_PENDING, then it
|
|
// is the same as what the serial driver set in ioStatusBlock.Status
|
|
//
|
|
|
|
if (status != STATUS_SUCCESS)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoCallDriver() failed. Returned = 0x%.8x\n", status));
|
|
|
|
goto done;
|
|
}
|
|
|
|
done:
|
|
DEBUGMSG(DBG_FUNC, ("-SerialSetXon\n"));
|
|
return status;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialSetXoff
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialSetXoff(
|
|
IN PDEVICE_OBJECT pSerialDevObj
|
|
)
|
|
{
|
|
PIRP pIrp;
|
|
KEVENT eventComplete;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
NTSTATUS status;
|
|
|
|
|
|
if (!pSerialDevObj)
|
|
{
|
|
DEBUGMSG(DBG_ERROR, ("IRSIR: SerialDevObj==NULL\n"));
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialSetXoff\n"));
|
|
|
|
//
|
|
// event to wait for completion of serial driver
|
|
//
|
|
|
|
KeInitializeEvent(
|
|
&eventComplete,
|
|
NotificationEvent,
|
|
FALSE
|
|
);
|
|
|
|
//
|
|
// build irp to set Xoff and wait for event signalled
|
|
//
|
|
// irp is released by io manager
|
|
//
|
|
|
|
pIrp = IoBuildDeviceIoControlRequest(
|
|
IOCTL_SERIAL_SET_XON, // io control code
|
|
pSerialDevObj, // device object
|
|
NULL, // input buffer
|
|
0, // input buffer length
|
|
NULL, // output buffer
|
|
0, // output buffer length
|
|
FALSE, // calls IRP_MJ_DEVICE_CONTROL
|
|
// rather than IRP_MJ_INTERNAL_DEVICE_CONTROL
|
|
&eventComplete, // event to wait for completion
|
|
&ioStatusBlock // io status block to be set
|
|
);
|
|
|
|
if (pIrp == NULL)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoBuildDeviceIoControlRequest() failed.\n"));
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
goto done;
|
|
}
|
|
|
|
status = IoCallDriver(pSerialDevObj, pIrp);
|
|
|
|
//
|
|
// if IoCallDriver returns STATUS_PENDING, we need to wait for the event
|
|
//
|
|
|
|
if (status == STATUS_PENDING)
|
|
{
|
|
KeWaitForSingleObject(
|
|
&eventComplete, // object to wait for
|
|
Executive, // reason to wait
|
|
KernelMode, // processor mode
|
|
FALSE, // alertable
|
|
NULL // timeout
|
|
);
|
|
|
|
//
|
|
// we can get the status of the IoCallDriver from the io status
|
|
// block
|
|
//
|
|
|
|
status = ioStatusBlock.Status;
|
|
}
|
|
|
|
//
|
|
// if IoCallDriver returns something other that STATUS_PENDING, then it
|
|
// is the same as what the serial driver set in ioStatusBlock.Status
|
|
//
|
|
|
|
if (status != STATUS_SUCCESS)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoCallDriver() failed. Returned = 0x%.8x\n", status));
|
|
|
|
goto done;
|
|
}
|
|
|
|
done:
|
|
DEBUGMSG(DBG_FUNC, ("-SerialSetXoff\n"));
|
|
return status;
|
|
}
|
|
#endif
|
|
#if 0
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialGetWaitMask
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialGetWaitMask(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
OUT ULONG *pWaitMask
|
|
)
|
|
{
|
|
PIRP pIrp;
|
|
ULONG WaitMask;
|
|
KEVENT eventComplete;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
NTSTATUS status;
|
|
|
|
|
|
if (!pSerialDevObj)
|
|
{
|
|
DEBUGMSG(DBG_ERROR, ("IRSIR: SerialDevObj==NULL\n"));
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialGetWaitMask\n"));
|
|
|
|
//
|
|
// event to wait for completion of serial driver
|
|
//
|
|
|
|
KeInitializeEvent(
|
|
&eventComplete,
|
|
NotificationEvent,
|
|
FALSE
|
|
);
|
|
|
|
//
|
|
// build irp to get baud rate and wait for event signalled
|
|
//
|
|
// irp is released by io manager
|
|
//
|
|
|
|
pIrp = IoBuildDeviceIoControlRequest(
|
|
IOCTL_SERIAL_GET_WAIT_MASK, // io control code
|
|
pSerialDevObj, // device object
|
|
NULL, // input buffer
|
|
0, // input buffer length
|
|
&WaitMask, // output buffer
|
|
sizeof(ULONG), // output buffer length
|
|
FALSE, // calls IRP_MJ_DEVICE_CONTROL
|
|
// rather than IRP_MJ_INTERNAL_DEVICE_CONTROL
|
|
&eventComplete, // event to wait for completion
|
|
&ioStatusBlock // io status block to be set
|
|
);
|
|
|
|
if (pIrp == NULL)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoBuildDeviceIoControlRequest() failed.\n"));
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
goto done;
|
|
}
|
|
|
|
status = IoCallDriver(pSerialDevObj, pIrp);
|
|
|
|
//
|
|
// if IoCallDriver returns STATUS_PENDING, we need to wait for the event
|
|
//
|
|
|
|
if (status == STATUS_PENDING)
|
|
{
|
|
KeWaitForSingleObject(
|
|
&eventComplete, // object to wait for
|
|
Executive, // reason to wait
|
|
KernelMode, // processor mode
|
|
FALSE, // alertable
|
|
NULL // timeout
|
|
);
|
|
|
|
//
|
|
// we can get the status of the IoCallDriver from the io status
|
|
// block
|
|
//
|
|
|
|
status = ioStatusBlock.Status;
|
|
}
|
|
|
|
//
|
|
// if IoCallDriver returns something other that STATUS_PENDING, then it
|
|
// is the same as what the serial driver set in ioStatusBlock.Status
|
|
//
|
|
|
|
if (status != STATUS_SUCCESS)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoCallDriver() failed. Returned = 0x%.8x\n", status));
|
|
|
|
goto done;
|
|
}
|
|
|
|
ASSERT(sizeof(*pWaitMask) >= sizeof(ULONG));
|
|
|
|
RtlCopyMemory(pWaitMask, &WaitMask, sizeof(ULONG));
|
|
|
|
done:
|
|
DEBUGMSG(DBG_FUNC, ("-SerialGetWaitMask\n"));
|
|
return status;
|
|
}
|
|
#endif
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialSetWaitMask
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialSetWaitMask(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
IN ULONG *pWaitMask
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialSetWaitMask\n"));
|
|
|
|
SendIoctlToSerial(
|
|
pSerialDevObj,
|
|
&ioStatusBlock,
|
|
IOCTL_SERIAL_SET_WAIT_MASK, // io control code
|
|
pWaitMask, // input buffer
|
|
sizeof(ULONG), // input buffer length
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialSetWaitMask\n"));
|
|
|
|
return ioStatusBlock.Status;
|
|
}
|
|
#if 0
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialWaitOnMask
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialWaitOnMask(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
OUT ULONG *pWaitOnMask
|
|
)
|
|
{
|
|
PIRP pIrp;
|
|
ULONG WaitOnMask;
|
|
KEVENT eventComplete;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
NTSTATUS status;
|
|
|
|
|
|
if (!pSerialDevObj)
|
|
{
|
|
DEBUGMSG(DBG_ERROR, ("IRSIR: SerialDevObj==NULL\n"));
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialWaitOnMask\n"));
|
|
|
|
//
|
|
// event to wait for completion of serial driver
|
|
//
|
|
|
|
KeInitializeEvent(
|
|
&eventComplete,
|
|
NotificationEvent,
|
|
FALSE
|
|
);
|
|
|
|
//
|
|
// build irp to get baud rate and wait for event signalled
|
|
//
|
|
// irp is released by io manager
|
|
//
|
|
|
|
pIrp = IoBuildDeviceIoControlRequest(
|
|
IOCTL_SERIAL_WAIT_ON_MASK, // io control code
|
|
pSerialDevObj, // device object
|
|
NULL, // input buffer
|
|
0, // input buffer length
|
|
&WaitOnMask, // output buffer
|
|
sizeof(ULONG), // output buffer length
|
|
FALSE, // calls IRP_MJ_DEVICE_CONTROL
|
|
// rather than IRP_MJ_INTERNAL_DEVICE_CONTROL
|
|
&eventComplete, // event to wait for completion
|
|
&ioStatusBlock // io status block to be set
|
|
);
|
|
|
|
if (pIrp == NULL)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoBuildDeviceIoControlRequest() failed.\n"));
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
goto done;
|
|
}
|
|
|
|
status = IoCallDriver(pSerialDevObj, pIrp);
|
|
|
|
//
|
|
// if IoCallDriver returns STATUS_PENDING, we need to wait for the event
|
|
//
|
|
|
|
if (status == STATUS_PENDING)
|
|
{
|
|
KeWaitForSingleObject(
|
|
&eventComplete, // object to wait for
|
|
Executive, // reason to wait
|
|
KernelMode, // processor mode
|
|
FALSE, // alertable
|
|
NULL // timeout
|
|
);
|
|
|
|
//
|
|
// we can get the status of the IoCallDriver from the io status
|
|
// block
|
|
//
|
|
|
|
status = ioStatusBlock.Status;
|
|
}
|
|
|
|
//
|
|
// if IoCallDriver returns something other that STATUS_PENDING, then it
|
|
// is the same as what the serial driver set in ioStatusBlock.Status
|
|
//
|
|
|
|
if (status != STATUS_SUCCESS)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoCallDriver() failed. Returned = 0x%.8x\n", status));
|
|
|
|
goto done;
|
|
}
|
|
|
|
*pWaitOnMask = WaitOnMask;
|
|
|
|
done:
|
|
DEBUGMSG(DBG_FUNC, ("-SerialWaitOnMask\n"));
|
|
return status;
|
|
}
|
|
#endif
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialCallbackOnMask
|
|
*
|
|
* Synopsis: Asynchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 10-03-1998 stana author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialCallbackOnMask(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
IN PIO_COMPLETION_ROUTINE pRoutine,
|
|
IN PIO_STATUS_BLOCK pIosb,
|
|
IN PVOID Context,
|
|
OUT PULONG pResult
|
|
)
|
|
{
|
|
PIRP pIrp;
|
|
NTSTATUS status;
|
|
|
|
|
|
if (!pSerialDevObj)
|
|
{
|
|
DEBUGMSG(DBG_ERROR, ("IRSIR: SerialDevObj==NULL\n"));
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialCallbackOnMask\n"));
|
|
|
|
NdisZeroMemory(pIosb, sizeof(IO_STATUS_BLOCK));
|
|
|
|
//
|
|
// build irp to get baud rate and wait for event signalled
|
|
//
|
|
// irp is released by io manager
|
|
//
|
|
|
|
pIrp = IoBuildDeviceIoControlRequest(
|
|
IOCTL_SERIAL_WAIT_ON_MASK, // io control code
|
|
pSerialDevObj, // device object
|
|
NULL, // input buffer
|
|
0, // input buffer length
|
|
pResult, // output buffer
|
|
sizeof(ULONG), // output buffer length
|
|
FALSE, // calls IRP_MJ_DEVICE_CONTROL
|
|
// rather than IRP_MJ_INTERNAL_DEVICE_CONTROL
|
|
NULL, // event to wait for completion
|
|
pIosb // io status block to be set
|
|
);
|
|
|
|
if (pIrp == NULL)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoBuildDeviceIoControlRequest() failed.\n"));
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
goto done;
|
|
}
|
|
|
|
IoSetCompletionRoutine(pIrp, pRoutine, Context, TRUE, TRUE, TRUE);
|
|
|
|
LOG_ENTRY('WI', Context, pIrp, 0);
|
|
status = IoCallDriver(pSerialDevObj, pIrp);
|
|
|
|
|
|
done:
|
|
DEBUGMSG(DBG_FUNC, ("-SerialCallbackOnMask\n"));
|
|
return status;
|
|
}
|
|
|
|
#if 0
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialGetChars
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialGetChars(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
OUT PSERIAL_CHARS pChars
|
|
)
|
|
{
|
|
PIRP pIrp;
|
|
SERIAL_CHARS Chars;
|
|
KEVENT eventComplete;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
NTSTATUS status;
|
|
|
|
|
|
if (!pSerialDevObj)
|
|
{
|
|
DEBUGMSG(DBG_ERROR, ("IRSIR: SerialDevObj==NULL\n"));
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialGetChars\n"));
|
|
|
|
//
|
|
// event to wait for completion of serial driver
|
|
//
|
|
|
|
KeInitializeEvent(
|
|
&eventComplete,
|
|
NotificationEvent,
|
|
FALSE
|
|
);
|
|
|
|
//
|
|
// build irp to get baud rate and wait for event signalled
|
|
//
|
|
// irp is released by io manager
|
|
//
|
|
|
|
pIrp = IoBuildDeviceIoControlRequest(
|
|
IOCTL_SERIAL_GET_CHARS, // io control code
|
|
pSerialDevObj, // device object
|
|
NULL, // input buffer
|
|
0, // input buffer length
|
|
&Chars, // output buffer
|
|
sizeof(SERIAL_CHARS), // output buffer length
|
|
FALSE, // calls IRP_MJ_DEVICE_CONTROL
|
|
// rather than IRP_MJ_INTERNAL_DEVICE_CONTROL
|
|
&eventComplete, // event to wait for completion
|
|
&ioStatusBlock // io status block to be set
|
|
);
|
|
|
|
if (pIrp == NULL)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoBuildDeviceIoControlRequest() failed.\n"));
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
goto done;
|
|
}
|
|
|
|
status = IoCallDriver(pSerialDevObj, pIrp);
|
|
|
|
//
|
|
// if IoCallDriver returns STATUS_PENDING, we need to wait for the event
|
|
//
|
|
|
|
if (status == STATUS_PENDING)
|
|
{
|
|
KeWaitForSingleObject(
|
|
&eventComplete, // object to wait for
|
|
Executive, // reason to wait
|
|
KernelMode, // processor mode
|
|
FALSE, // alertable
|
|
NULL // timeout
|
|
);
|
|
|
|
//
|
|
// we can get the status of the IoCallDriver from the io status
|
|
// block
|
|
//
|
|
|
|
status = ioStatusBlock.Status;
|
|
}
|
|
|
|
//
|
|
// if IoCallDriver returns something other that STATUS_PENDING, then it
|
|
// is the same as what the serial driver set in ioStatusBlock.Status
|
|
//
|
|
|
|
if (status != STATUS_SUCCESS)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoCallDriver() failed. Returned = 0x%.8x\n", status));
|
|
|
|
goto done;
|
|
}
|
|
|
|
ASSERT(sizeof(*pChars) >= sizeof(SERIAL_CHARS));
|
|
|
|
RtlCopyMemory(pChars, &Chars, sizeof(SERIAL_CHARS));
|
|
|
|
done:
|
|
DEBUGMSG(DBG_FUNC, ("-SerialGetChars\n"));
|
|
return status;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Function: SerialSetChars
|
|
*
|
|
* Synopsis: Synchronous I/O control request to serial device object.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Returns: STATUS_SUCCESS
|
|
* STATUS_INSUFFICIENT_RESOURCES
|
|
* STATUS_UNSUCCESSFUL or other failure if IoCallDriver fails
|
|
*
|
|
* Algorithm:
|
|
*
|
|
* History: dd-mm-yyyy Author Comment
|
|
* 9/30/1996 sholden author
|
|
*
|
|
* Notes:
|
|
*
|
|
* This routine must be called from IRQL PASSIVE_LEVEL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
NTSTATUS
|
|
SerialSetChars(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
IN PSERIAL_CHARS pChars
|
|
)
|
|
{
|
|
PIRP pIrp;
|
|
KEVENT eventComplete;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
NTSTATUS status;
|
|
|
|
|
|
if (!pSerialDevObj)
|
|
{
|
|
DEBUGMSG(DBG_ERROR, ("IRSIR: SerialDevObj==NULL\n"));
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialSetChars\n"));
|
|
|
|
//
|
|
// event to wait for completion of serial driver
|
|
//
|
|
|
|
KeInitializeEvent(
|
|
&eventComplete,
|
|
NotificationEvent,
|
|
FALSE
|
|
);
|
|
|
|
//
|
|
// build irp to set baud rate and wait for event signalled
|
|
//
|
|
// irp is released by io manager
|
|
//
|
|
|
|
pIrp = IoBuildDeviceIoControlRequest(
|
|
IOCTL_SERIAL_SET_CHARS, // io control code
|
|
pSerialDevObj, // device object
|
|
pChars, // input buffer
|
|
sizeof(SERIAL_CHARS), // input buffer length
|
|
NULL, // output buffer
|
|
0, // output buffer length
|
|
FALSE, // calls IRP_MJ_DEVICE_CONTROL
|
|
// rather than IRP_MJ_INTERNAL_DEVICE_CONTROL
|
|
&eventComplete, // event to wait for completion
|
|
&ioStatusBlock // io status block to be set
|
|
);
|
|
|
|
if (pIrp == NULL)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoBuildDeviceIoControlRequest() failed.\n"));
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
goto done;
|
|
}
|
|
|
|
status = IoCallDriver(pSerialDevObj, pIrp);
|
|
|
|
//
|
|
// if IoCallDriver returns STATUS_PENDING, we need to wait for the event
|
|
//
|
|
|
|
if (status == STATUS_PENDING)
|
|
{
|
|
KeWaitForSingleObject(
|
|
&eventComplete, // object to wait for
|
|
Executive, // reason to wait
|
|
KernelMode, // processor mode
|
|
FALSE, // alertable
|
|
NULL // timeout
|
|
);
|
|
|
|
//
|
|
// we can get the status of the IoCallDriver from the io status
|
|
// block
|
|
//
|
|
|
|
status = ioStatusBlock.Status;
|
|
}
|
|
|
|
//
|
|
// if IoCallDriver returns something other that STATUS_PENDING, then it
|
|
// is the same as what the serial driver set in ioStatusBlock.Status
|
|
//
|
|
|
|
if (status != STATUS_SUCCESS)
|
|
{
|
|
DEBUGMSG(DBG_OUT, (" IoCallDriver() failed. Returned = 0x%.8x\n", status));
|
|
|
|
goto done;
|
|
}
|
|
|
|
done:
|
|
DEBUGMSG(DBG_FUNC, ("-SerialSetChars\n"));
|
|
return status;
|
|
}
|
|
#endif
|
|
|
|
NTSTATUS IrpCompleteSetEvent(IN PDEVICE_OBJECT pDevObj,
|
|
IN PIRP pIrp,
|
|
IN PVOID pContext)
|
|
{
|
|
PKEVENT pEvent = pContext;
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+IrpCompleteSetEvent\n"));
|
|
KeSetEvent(pEvent, 0, FALSE);
|
|
|
|
*pIrp->UserIosb = pIrp->IoStatus;
|
|
|
|
IoFreeIrp(pIrp);
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-IrpCompleteSetEvent\n"));
|
|
return STATUS_MORE_PROCESSING_REQUIRED;
|
|
}
|
|
NTSTATUS
|
|
SerialFlush(IN PDEVICE_OBJECT pSerialDevObj)
|
|
{
|
|
PIRP Irp;
|
|
PIO_STACK_LOCATION IrpSp;
|
|
NTSTATUS Status;
|
|
KEVENT Event;
|
|
IO_STATUS_BLOCK IOStatus;
|
|
ULONG WaitMask = SERIAL_EV_TXEMPTY;
|
|
|
|
if (!pSerialDevObj)
|
|
{
|
|
DEBUGMSG(DBG_ERROR, ("IRSIR: SerialDevObj==NULL\n"));
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialFlush\n"));
|
|
|
|
ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
|
|
|
|
KeInitializeEvent( &Event, NotificationEvent, FALSE );
|
|
|
|
RtlZeroMemory(&IOStatus, sizeof(IOStatus));
|
|
|
|
Irp = SerialBuildReadWriteIrp(pSerialDevObj,
|
|
IRP_MJ_FLUSH_BUFFERS,
|
|
NULL,
|
|
0,
|
|
&IOStatus);
|
|
|
|
if (Irp == NULL)
|
|
{
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto sfDone;
|
|
}
|
|
|
|
IoSetCompletionRoutine(Irp,
|
|
IrpCompleteSetEvent,
|
|
&Event,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE);
|
|
|
|
Status = IoCallDriver(pSerialDevObj, Irp);
|
|
|
|
if (Status == STATUS_PENDING)
|
|
{
|
|
KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, NULL );
|
|
}
|
|
Status = IOStatus.Status;
|
|
|
|
sfDone:
|
|
|
|
#if DBG
|
|
if (Status != STATUS_SUCCESS)
|
|
{
|
|
DEBUGMSG(DBG_ERR, (" SerialFlush() Failed. 0x%08X\n\n", Status));
|
|
}
|
|
#endif
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialFlush\n"));
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
SerialSynchronousWrite(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
IN PVOID pBuffer,
|
|
IN ULONG dwLength,
|
|
OUT PULONG pdwBytesWritten)
|
|
{
|
|
PIRP Irp;
|
|
PIO_STACK_LOCATION IrpSp;
|
|
NTSTATUS Status;
|
|
KEVENT Event;
|
|
IO_STATUS_BLOCK IOStatus;
|
|
ULONG WaitMask = SERIAL_EV_TXEMPTY;
|
|
|
|
if (!pSerialDevObj)
|
|
{
|
|
DEBUGMSG(DBG_ERROR, ("IRSIR: SerialDevObj==NULL\n"));
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialSynchronousWrite\n"));
|
|
|
|
ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
|
|
|
|
//(void)SerialSetWaitMask(pSerialDevObj, &WaitMask);
|
|
|
|
KeInitializeEvent( &Event, NotificationEvent, FALSE );
|
|
|
|
RtlZeroMemory(&IOStatus, sizeof(IOStatus));
|
|
|
|
Irp = SerialBuildReadWriteIrp(pSerialDevObj,
|
|
IRP_MJ_WRITE,
|
|
pBuffer,
|
|
dwLength,
|
|
&IOStatus);
|
|
|
|
if (Irp == NULL)
|
|
{
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto sswDone;
|
|
}
|
|
|
|
IoSetCompletionRoutine(Irp,
|
|
IrpCompleteSetEvent,
|
|
&Event,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE);
|
|
|
|
Status = IoCallDriver(pSerialDevObj, Irp);
|
|
|
|
if (Status == STATUS_PENDING)
|
|
{
|
|
KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, NULL );
|
|
}
|
|
Status = IOStatus.Status;
|
|
|
|
// This truncates if 64 bits. Don't think we'll be reading or writing more than
|
|
// 4.5 GB to a serial port soon.
|
|
*pdwBytesWritten = (ULONG)IOStatus.Information;
|
|
|
|
(void)SerialFlush(pSerialDevObj);
|
|
//(void)SerialWaitOnMask(pSerialDevObj, &WaitMask);
|
|
|
|
sswDone:
|
|
|
|
#if DBG
|
|
if (Status != STATUS_SUCCESS)
|
|
{
|
|
DEBUGMSG(DBG_ERR, (" SerialSynchronousWrite() Failed. 0x%08X\n\n", Status));
|
|
}
|
|
#endif
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialSynchronousWrite\n"));
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
SerialSynchronousRead(
|
|
IN PDEVICE_OBJECT pSerialDevObj,
|
|
OUT PVOID pBuffer,
|
|
IN ULONG dwLength,
|
|
OUT PULONG pdwBytesRead)
|
|
{
|
|
PIRP Irp;
|
|
PIO_STACK_LOCATION IrpSp;
|
|
NTSTATUS Status;
|
|
KEVENT Event;
|
|
IO_STATUS_BLOCK IOStatus;
|
|
|
|
*pdwBytesRead = 0;
|
|
|
|
if (!pSerialDevObj)
|
|
{
|
|
DEBUGMSG(DBG_ERROR, ("IRSIR: SerialDevObj==NULL\n"));
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
DEBUGMSG(DBG_FUNC, ("+SerialSynchronousRead\n"));
|
|
|
|
ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
|
|
|
|
KeInitializeEvent( &Event, NotificationEvent, FALSE );
|
|
|
|
RtlZeroMemory(&IOStatus, sizeof(IOStatus));
|
|
|
|
Irp = SerialBuildReadWriteIrp(pSerialDevObj,
|
|
IRP_MJ_READ,
|
|
pBuffer,
|
|
dwLength,
|
|
&IOStatus);
|
|
|
|
if (Irp == NULL)
|
|
{
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto ssrDone;
|
|
}
|
|
|
|
IoSetCompletionRoutine(Irp,
|
|
IrpCompleteSetEvent,
|
|
&Event,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE);
|
|
|
|
Status = IoCallDriver(pSerialDevObj, Irp);
|
|
|
|
if (Status == STATUS_PENDING)
|
|
{
|
|
KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, NULL );
|
|
}
|
|
|
|
Status = IOStatus.Status;
|
|
|
|
// This truncates if 64 bits. Don't think we'll be reading or writing more than
|
|
// 4.5 GB to a serial port soon.
|
|
*pdwBytesRead = (ULONG)IOStatus.Information;
|
|
|
|
|
|
ssrDone:
|
|
|
|
#if DBG
|
|
if (Status != STATUS_SUCCESS)
|
|
{
|
|
DEBUGMSG(DBG_WARN, (" SerialSynchronousRead() Failed. 0x%08X\n\n", Status));
|
|
}
|
|
#endif
|
|
|
|
DEBUGMSG(DBG_FUNC, ("-SerialSynchronousRead\n"));
|
|
return Status;
|
|
}
|