NTSTATUS c0cOpen(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp)
{
NTSTATUS status;
PC0C_COMMON_EXTENSION pDevExt = pDevObj->DeviceExtension;
TraceIrp("--- Open ---", pIrp, NULL, TRACE_FLAG_PARAMS);
switch (pDevExt->doType) {
case C0C_DOTYPE_FP:
status = FdoPortOpen((PC0C_FDOPORT_EXTENSION)pDevExt);
break;
default:
status = STATUS_INVALID_DEVICE_REQUEST;
}
pIrp->IoStatus.Information = 0;
#if ENABLE_TRACING
if (!NT_SUCCESS(status))
TraceIrp("c0cOpen", pIrp, &status, TRACE_FLAG_RESULTS);
#endif /* ENABLE_TRACING */
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
return status;
}
NTSTATUS c0cCleanup(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp)
{
NTSTATUS status;
PC0C_COMMON_EXTENSION pDevExt = pDevObj->DeviceExtension;
TraceIrp("c0cCleanup", pIrp, NULL, TRACE_FLAG_PARAMS);
switch (pDevExt->doType) {
case C0C_DOTYPE_FP:
FdoPortCancelQueues(((PC0C_FDOPORT_EXTENSION)pDevExt)->pIoPortLocal);
status = STATUS_SUCCESS;
break;
default:
status = STATUS_INVALID_DEVICE_REQUEST;
}
pIrp->IoStatus.Information = 0;
TraceIrp("c0cCleanup", pIrp, &status, TRACE_FLAG_RESULTS);
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
return status;
}
NTSTATUS c0cWrite(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp)
{
NTSTATUS status;
PC0C_COMMON_EXTENSION pDevExt = pDevObj->DeviceExtension;
#if ENABLE_TRACING
ULONG code = IoGetCurrentIrpStackLocation(pIrp)->MajorFunction;
#endif /* ENABLE_TRACING */
TraceIrp("c0cWrite", pIrp, NULL, TRACE_FLAG_PARAMS);
switch (pDevExt->doType) {
case C0C_DOTYPE_FP:
status = FdoPortWrite(((PC0C_FDOPORT_EXTENSION)pDevExt)->pIoPortLocal, pIrp);
break;
default:
status = STATUS_INVALID_DEVICE_REQUEST;
pIrp->IoStatus.Information = 0;
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
}
if (!NT_SUCCESS(status))
TraceCode(pDevExt, "IRP_MJ_", codeNameTableIrpMj, code, &status);
return status;
}
NTSTATUS FdoPortSetInformation(PC0C_IO_PORT pIoPortLocal, IN PIRP pIrp)
{
NTSTATUS status;
if ((pIoPortLocal->handFlow.ControlHandShake & SERIAL_ERROR_ABORT) && pIoPortLocal->errors) {
status = STATUS_CANCELLED;
} else {
PIO_STACK_LOCATION pIrpStack;
pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
switch (pIrpStack->Parameters.QueryFile.FileInformationClass) {
case FileEndOfFileInformation:
case FileAllocationInformation:
status = STATUS_SUCCESS;
break;
default:
status = STATUS_INVALID_PARAMETER;
}
}
TraceIrp("FdoPortSetInformation", pIrp, &status, TRACE_FLAG_PARAMS);
pIrp->IoStatus.Information = 0;
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
return status;
}
NTSTATUS c0cPowerDispatch(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp)
{
NTSTATUS status;
PC0C_COMMON_EXTENSION pDevExt = pDevObj->DeviceExtension;
HALT_UNLESS2(IoGetCurrentIrpStackLocation(pIrp)->MajorFunction == IRP_MJ_POWER,
IoGetCurrentIrpStackLocation(pIrp)->MajorFunction,
IoGetCurrentIrpStackLocation(pIrp)->MinorFunction);
TraceIrp("POWER", pIrp, NULL, TRACE_FLAG_PARAMS);
switch (pDevExt->doType) {
case C0C_DOTYPE_FB:
case C0C_DOTYPE_FP:
PoStartNextPowerIrp(pIrp);
IoSkipCurrentIrpStackLocation(pIrp);
status = PoCallDriver(((PC0C_COMMON_FDO_EXTENSION)pDevExt)->pLowDevObj, pIrp);
break;
case C0C_DOTYPE_PP:
status = PdoPortPower((PC0C_PDOPORT_EXTENSION)pDevExt, pIrp);
break;
default:
status = STATUS_NO_SUCH_DEVICE;
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
}
return status;
}
VOID FdoPortCompleteQueue(IN PLIST_ENTRY pQueueToComplete)
{
while (!IsListEmpty(pQueueToComplete)) {
PIRP pIrp;
PC0C_IRP_STATE pState;
PLIST_ENTRY pListEntry;
PIO_STACK_LOCATION pIrpStack;
pListEntry = RemoveHeadList(pQueueToComplete);
pIrp = CONTAINING_RECORD(pListEntry, IRP, Tail.Overlay.ListEntry);
pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
if (pIrp->IoStatus.Status == STATUS_TIMEOUT && pIrp->IoStatus.Information &&
pIrpStack->MajorFunction == IRP_MJ_DEVICE_CONTROL &&
pIrpStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_SERIAL_XOFF_COUNTER)
{
pIrp->IoStatus.Status = STATUS_SERIAL_COUNTER_TIMEOUT;
}
TraceIrp("complete", pIrp, &pIrp->IoStatus.Status, TRACE_FLAG_RESULTS);
pState = GetIrpState(pIrp);
HALT_UNLESS(pState);
if (pState->iQueue == C0C_QUEUE_WRITE) {
KIRQL oldIrql;
PC0C_IO_PORT pIoPort;
pIoPort = FDO_PORT_TO_IO_PORT(IoGetCurrentIrpStackLocation(pIrp)->DeviceObject);
KeAcquireSpinLock(pIoPort->pIoLock, &oldIrql);
pIoPort->amountInWriteQueue -=
GetWriteLength(pIrp) - (ULONG)pIrp->IoStatus.Information;
KeReleaseSpinLock(pIoPort->pIoLock, oldIrql);
}
if (pIrp->IoStatus.Status == STATUS_CANCELLED ||
(pIrpStack->MajorFunction == IRP_MJ_DEVICE_CONTROL &&
(pIrpStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_SERIAL_IMMEDIATE_CHAR ||
pIrpStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_SERIAL_XOFF_COUNTER)))
{
pIrp->IoStatus.Information = 0;
}
IoCompleteRequest(pIrp, IO_SERIAL_INCREMENT);
}
}
NTSTATUS FdoPortQueryInformation(PC0C_IO_PORT pIoPortLocal, IN PIRP pIrp)
{
NTSTATUS status;
pIrp->IoStatus.Information = 0;
if ((pIoPortLocal->handFlow.ControlHandShake & SERIAL_ERROR_ABORT) && pIoPortLocal->errors) {
status = STATUS_CANCELLED;
} else {
PIO_STACK_LOCATION pIrpStack;
pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
switch (pIrpStack->Parameters.QueryFile.FileInformationClass) {
case FileStandardInformation:
if (pIrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(FILE_STANDARD_INFORMATION)) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
RtlZeroMemory(pIrp->AssociatedIrp.SystemBuffer, sizeof(FILE_STANDARD_INFORMATION));
pIrp->IoStatus.Information = sizeof(FILE_STANDARD_INFORMATION);
status = STATUS_SUCCESS;
break;
case FilePositionInformation:
if (pIrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(FILE_POSITION_INFORMATION)) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
RtlZeroMemory(pIrp->AssociatedIrp.SystemBuffer, sizeof(FILE_POSITION_INFORMATION));
pIrp->IoStatus.Information = sizeof(FILE_POSITION_INFORMATION);
status = STATUS_SUCCESS;
break;
default:
status = STATUS_INVALID_PARAMETER;
}
}
TraceIrp("FdoPortQueryInformation", pIrp, &status, TRACE_FLAG_PARAMS);
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
return status;
}
NTSTATUS FdoPortWrite(IN PC0C_IO_PORT pIoPort, IN PIRP pIrp)
{
NTSTATUS status;
pIrp->IoStatus.Information = 0;
if ((pIoPort->handFlow.ControlHandShake & SERIAL_ERROR_ABORT) && pIoPort->errors) {
status = STATUS_CANCELLED;
} else {
if (IoGetCurrentIrpStackLocation(pIrp)->MajorFunction == IRP_MJ_FLUSH_BUFFERS ||
IoGetCurrentIrpStackLocation(pIrp)->Parameters.Write.Length)
status = FdoPortStartIrp(pIoPort, pIrp, C0C_QUEUE_WRITE, StartIrpWrite);
else
status = STATUS_SUCCESS;
}
if (status != STATUS_PENDING) {
TraceIrp("FdoPortWrite", pIrp, &status, TRACE_FLAG_RESULTS);
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
}
return status;
}
NTSTATUS FdoPortIoCtl(
IN PC0C_FDOPORT_EXTENSION pDevExt,
IN PIRP pIrp)
{
NTSTATUS status;
PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
ULONG code = pIrpStack->Parameters.DeviceIoControl.IoControlCode;
KIRQL oldIrql;
PC0C_IO_PORT pIoPortLocal;
pIrp->IoStatus.Information = 0;
pIoPortLocal = pDevExt->pIoPortLocal;
if ((pIoPortLocal->handFlow.ControlHandShake & SERIAL_ERROR_ABORT) &&
pIoPortLocal->errors && code != IOCTL_SERIAL_GET_COMMSTATUS)
{
status = STATUS_CANCELLED;
} else {
status = STATUS_SUCCESS;
switch (code) {
case IOCTL_SERIAL_SET_RTS:
case IOCTL_SERIAL_CLR_RTS:
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
switch (pIoPortLocal->handFlow.FlowReplace & SERIAL_RTS_MASK) {
case SERIAL_RTS_HANDSHAKE:
case SERIAL_TRANSMIT_TOGGLE:
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
status = STATUS_INVALID_PARAMETER;
break;
default: {
LIST_ENTRY queueToComplete;
InitializeListHead(&queueToComplete);
SetModemControl(
pIoPortLocal,
code == IOCTL_SERIAL_SET_RTS ? C0C_MCR_RTS : 0,
C0C_MCR_RTS,
&queueToComplete);
if (pIoPortLocal->pIoPortRemote->tryWrite || pIoPortLocal->tryWrite) {
ReadWrite(
pIoPortLocal, FALSE,
pIoPortLocal->pIoPortRemote, FALSE,
&queueToComplete);
}
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
FdoPortCompleteQueue(&queueToComplete);
}
}
break;
case IOCTL_SERIAL_SET_DTR:
case IOCTL_SERIAL_CLR_DTR:
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
switch (pIoPortLocal->handFlow.ControlHandShake & SERIAL_DTR_MASK) {
case SERIAL_DTR_HANDSHAKE:
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
status = STATUS_INVALID_PARAMETER;
break;
default: {
LIST_ENTRY queueToComplete;
InitializeListHead(&queueToComplete);
SetModemControl(
pIoPortLocal,
code == IOCTL_SERIAL_SET_DTR ? C0C_MCR_DTR : 0,
C0C_MCR_DTR,
&queueToComplete);
if (pIoPortLocal->pIoPortRemote->tryWrite || pIoPortLocal->tryWrite) {
ReadWrite(
pIoPortLocal, FALSE,
pIoPortLocal->pIoPortRemote, FALSE,
&queueToComplete);
}
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
FdoPortCompleteQueue(&queueToComplete);
}
}
break;
case IOCTL_SERIAL_SET_MODEM_CONTROL: {
LIST_ENTRY queueToComplete;
UCHAR mask;
PUCHAR pSysBuf;
ULONG InputBufferLength;
InputBufferLength = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
if (InputBufferLength < sizeof(ULONG)) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
pSysBuf = (PUCHAR)pIrp->AssociatedIrp.SystemBuffer;
if (InputBufferLength >= (sizeof(ULONG) + sizeof(ULONG) + C0CE_SIGNATURE_SIZE) &&
RtlEqualMemory(pSysBuf + sizeof(ULONG) + sizeof(ULONG), C0CE_SIGNATURE, C0CE_SIGNATURE_SIZE))
{
mask = C0C_MCR_MASK & (UCHAR)*((PULONG)pSysBuf + 1);
} else {
mask = C0C_MCR_MASK;
}
InitializeListHead(&queueToComplete);
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
SetModemControl(pIoPortLocal, (UCHAR)*(PULONG)pSysBuf, mask, &queueToComplete);
if (pIoPortLocal->pIoPortRemote->tryWrite || pIoPortLocal->tryWrite) {
ReadWrite(
pIoPortLocal, FALSE,
pIoPortLocal->pIoPortRemote, FALSE,
&queueToComplete);
}
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
FdoPortCompleteQueue(&queueToComplete);
break;
}
case IOCTL_SERIAL_GET_MODEM_CONTROL:
case IOCTL_SERIAL_GET_DTRRTS: {
ULONG modemControl;
PUCHAR pSysBuf;
ULONG OutputBufferLength;
OutputBufferLength = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;
if (OutputBufferLength < sizeof(ULONG)) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
modemControl = pIoPortLocal->modemControl;
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
pSysBuf = (PUCHAR)pIrp->AssociatedIrp.SystemBuffer;
if (code == IOCTL_SERIAL_GET_DTRRTS) {
modemControl &= SERIAL_DTR_STATE | SERIAL_RTS_STATE;
pIrp->IoStatus.Information = sizeof(ULONG);
} else {
ULONG InputBufferLength;
InputBufferLength = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
if (OutputBufferLength >= (sizeof(ULONG) + C0CE_SIGNATURE_SIZE) &&
InputBufferLength >= C0CE_SIGNATURE_SIZE &&
RtlEqualMemory(pSysBuf, C0CE_SIGNATURE, C0CE_SIGNATURE_SIZE))
{
RtlCopyMemory(pSysBuf + sizeof(PULONG), C0CE_SIGNATURE, C0CE_SIGNATURE_SIZE);
if (OutputBufferLength > (sizeof(ULONG) + C0CE_SIGNATURE_SIZE)) {
RtlZeroMemory(pSysBuf + sizeof(ULONG) + C0CE_SIGNATURE_SIZE,
OutputBufferLength - (sizeof(ULONG) + C0CE_SIGNATURE_SIZE));
}
pIrp->IoStatus.Information = OutputBufferLength;
} else {
pIrp->IoStatus.Information = sizeof(ULONG);
}
modemControl &= C0C_MCR_MASK;
}
*(PULONG)pSysBuf = modemControl;
TraceIrp("FdoPortIoCtl", pIrp, &status, TRACE_FLAG_RESULTS);
break;
}
case IOCTL_SERIAL_SET_XON: {
LIST_ENTRY queueToComplete;
InitializeListHead(&queueToComplete);
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
SetXonXoffHolding(pIoPortLocal, C0C_XCHAR_ON);
if (pIoPortLocal->tryWrite) {
ReadWrite(
pIoPortLocal, FALSE,
pIoPortLocal->pIoPortRemote, FALSE,
&queueToComplete);
}
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
FdoPortCompleteQueue(&queueToComplete);
break;
}
case IOCTL_SERIAL_SET_XOFF:
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
SetXonXoffHolding(pIoPortLocal, C0C_XCHAR_OFF);
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
break;
case IOCTL_SERIAL_SET_BREAK_ON: {
LIST_ENTRY queueToComplete;
InitializeListHead(&queueToComplete);
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
SetBreakHolding(pIoPortLocal, TRUE, &queueToComplete);
UpdateTransmitToggle(pIoPortLocal, &queueToComplete);
ReadWrite(
pIoPortLocal, FALSE,
pIoPortLocal->pIoPortRemote, FALSE,
&queueToComplete);
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
FdoPortCompleteQueue(&queueToComplete);
break;
}
case IOCTL_SERIAL_SET_BREAK_OFF: {
LIST_ENTRY queueToComplete;
InitializeListHead(&queueToComplete);
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
SetBreakHolding(pIoPortLocal, FALSE, &queueToComplete);
UpdateTransmitToggle(pIoPortLocal, &queueToComplete);
if (pIoPortLocal->tryWrite || pIoPortLocal->pIoPortRemote->tryWrite) {
ReadWrite(
pIoPortLocal, FALSE,
pIoPortLocal->pIoPortRemote, FALSE,
&queueToComplete);
}
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
FdoPortCompleteQueue(&queueToComplete);
break;
}
case IOCTL_SERIAL_GET_MODEMSTATUS:
if (pIrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG)) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
*(PULONG)pIrp->AssociatedIrp.SystemBuffer = pIoPortLocal->modemStatus;
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
pIrp->IoStatus.Information = sizeof(ULONG);
TraceIrp("FdoPortIoCtl", pIrp, &status, TRACE_FLAG_RESULTS);
break;
case IOCTL_SERIAL_SET_WAIT_MASK:
status = FdoPortSetWaitMask(pIoPortLocal, pIrp, pIrpStack);
break;
case IOCTL_SERIAL_GET_WAIT_MASK:
status = FdoPortGetWaitMask(pIoPortLocal, pIrp, pIrpStack);
TraceIrp("FdoPortIoCtl", pIrp, &status, TRACE_FLAG_RESULTS);
break;
case IOCTL_SERIAL_WAIT_ON_MASK:
status = FdoPortWaitOnMask(pIoPortLocal, pIrp, pIrpStack);
#if ENABLE_TRACING
if (status == STATUS_SUCCESS)
TraceIrp("FdoPortIoCtl", pIrp, &status, TRACE_FLAG_RESULTS);
#endif /* ENABLE_TRACING */
break;
case IOCTL_SERIAL_IMMEDIATE_CHAR:
status = FdoPortImmediateChar(pIoPortLocal, pIrp, pIrpStack);
break;
case IOCTL_SERIAL_XOFF_COUNTER:
status = FdoPortXoffCounter(pIoPortLocal, pIrp, pIrpStack);
break;
case IOCTL_SERIAL_PURGE: {
LIST_ENTRY queueToComplete;
PULONG pSysBuf;
if (pIrpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(ULONG)) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
pSysBuf = (PULONG)pIrp->AssociatedIrp.SystemBuffer;
if (*pSysBuf & ~(
SERIAL_PURGE_TXABORT |
SERIAL_PURGE_RXABORT |
SERIAL_PURGE_TXCLEAR |
SERIAL_PURGE_RXCLEAR
)) {
status = STATUS_INVALID_PARAMETER;
break;
}
InitializeListHead(&queueToComplete);
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
if (*pSysBuf & SERIAL_PURGE_RXABORT)
CancelQueue(&pIoPortLocal->irpQueues[C0C_QUEUE_READ], &queueToComplete);
if (*pSysBuf & SERIAL_PURGE_TXABORT)
CancelQueue(&pIoPortLocal->irpQueues[C0C_QUEUE_WRITE], &queueToComplete);
if (*pSysBuf & SERIAL_PURGE_RXCLEAR) {
PurgeBuffer(&pIoPortLocal->readBuf);
UpdateHandFlow(pIoPortLocal, TRUE, &queueToComplete);
if (pIoPortLocal->tryWrite || pIoPortLocal->pIoPortRemote->tryWrite) {
ReadWrite(
pIoPortLocal, FALSE,
pIoPortLocal->pIoPortRemote, FALSE,
&queueToComplete);
}
}
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
FdoPortCompleteQueue(&queueToComplete);
break;
}
case IOCTL_SERIAL_GET_COMMSTATUS: {
PSERIAL_STATUS pSysBuf;
PIRP pIrpWrite;
if (pIrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(SERIAL_STATUS)) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
pSysBuf = (PSERIAL_STATUS)pIrp->AssociatedIrp.SystemBuffer;
RtlZeroMemory(pSysBuf, sizeof(*pSysBuf));
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
pSysBuf->AmountInInQueue = (ULONG)C0C_BUFFER_BUSY(&pIoPortLocal->readBuf);
pIrpWrite = pIoPortLocal->irpQueues[C0C_QUEUE_WRITE].pCurrent;
if (pIrpWrite) {
PIO_STACK_LOCATION pIrpStackWrite = IoGetCurrentIrpStackLocation(pIrpWrite);
if (pIrpStackWrite->MajorFunction == IRP_MJ_DEVICE_CONTROL &&
pIrpStackWrite->Parameters.DeviceIoControl.IoControlCode == IOCTL_SERIAL_IMMEDIATE_CHAR)
{
pSysBuf->WaitForImmediate = TRUE;
}
}
pSysBuf->AmountInOutQueue = pIoPortLocal->amountInWriteQueue;
pSysBuf->HoldReasons = pIoPortLocal->writeHolding;
if ((pIoPortLocal->handFlow.ControlHandShake & SERIAL_DSR_SENSITIVITY) &&
(pIoPortLocal->modemStatus & C0C_MSB_DSR) == 0)
{
pSysBuf->HoldReasons |= SERIAL_RX_WAITING_FOR_DSR;
}
if (pIoPortLocal->writeHoldingRemote & SERIAL_TX_WAITING_FOR_XON)
pSysBuf->HoldReasons |= SERIAL_TX_WAITING_XOFF_SENT;
pSysBuf->Errors = pIoPortLocal->errors;
pIoPortLocal->errors = 0;
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
pIrp->IoStatus.Information = sizeof(SERIAL_STATUS);
TraceIrp("FdoPortIoCtl", pIrp, &status, TRACE_FLAG_RESULTS);
break;
}
case IOCTL_SERIAL_SET_HANDFLOW: {
LIST_ENTRY queueToComplete;
PSERIAL_HANDFLOW pSysBuf;
if (pIrpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(SERIAL_HANDFLOW)) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
pSysBuf = (PSERIAL_HANDFLOW)pIrp->AssociatedIrp.SystemBuffer;
if (pSysBuf->ControlHandShake & SERIAL_CONTROL_INVALID ||
pSysBuf->FlowReplace & SERIAL_FLOW_INVALID ||
(pSysBuf->ControlHandShake & SERIAL_DTR_MASK) == SERIAL_DTR_MASK ||
pSysBuf->XonLimit < 0 ||
pSysBuf->XoffLimit < 0)
{
status = STATUS_INVALID_PARAMETER;
break;
}
InitializeListHead(&queueToComplete);
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
status = SetHandFlow(pIoPortLocal, pSysBuf, &queueToComplete);
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
FdoPortCompleteQueue(&queueToComplete);
break;
}
case IOCTL_SERIAL_GET_HANDFLOW:
if (pIrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(SERIAL_HANDFLOW)) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
*(PSERIAL_HANDFLOW)pIrp->AssociatedIrp.SystemBuffer = pIoPortLocal->handFlow;
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
pIrp->IoStatus.Information = sizeof(SERIAL_HANDFLOW);
TraceIrp("FdoPortIoCtl", pIrp, &status, TRACE_FLAG_RESULTS);
break;
case IOCTL_SERIAL_SET_TIMEOUTS:
status = FdoPortSetTimeouts(pIoPortLocal, pIrp, pIrpStack);
break;
case IOCTL_SERIAL_GET_TIMEOUTS:
status = FdoPortGetTimeouts(pIoPortLocal, pIrp, pIrpStack);
TraceIrp("FdoPortIoCtl", pIrp, &status, TRACE_FLAG_RESULTS);
break;
case IOCTL_SERIAL_SET_CHARS: {
PSERIAL_CHARS pSysBuf;
if (pIrpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(SERIAL_CHARS)) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
pSysBuf = (PSERIAL_CHARS)pIrp->AssociatedIrp.SystemBuffer;
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
if (pIoPortLocal->escapeChar &&
((pIoPortLocal->escapeChar == pSysBuf->XoffChar) ||
(pIoPortLocal->escapeChar == pSysBuf->XonChar)))
{
status = STATUS_INVALID_PARAMETER;
}
if (status == STATUS_SUCCESS)
pIoPortLocal->specialChars = *pSysBuf;
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
break;
}
case IOCTL_SERIAL_GET_CHARS:
if (pIrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(SERIAL_CHARS)) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
*(PSERIAL_CHARS)pIrp->AssociatedIrp.SystemBuffer = pIoPortLocal->specialChars;
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
pIrp->IoStatus.Information = sizeof(SERIAL_CHARS);
TraceIrp("FdoPortIoCtl", pIrp, &status, TRACE_FLAG_RESULTS);
break;
case IOCTL_SERIAL_LSRMST_INSERT: {
ULONG Information;
ULONG optsAndBits;
UCHAR escapeChar;
PUCHAR pSysBuf;
ULONG InputBufferLength;
BOOLEAN extended;
InputBufferLength = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
if (InputBufferLength < sizeof(UCHAR)) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
Information = 0;
pSysBuf = (PUCHAR)pIrp->AssociatedIrp.SystemBuffer;
escapeChar = *pSysBuf;
if (InputBufferLength >= (sizeof(UCHAR) + C0CE_SIGNATURE_SIZE + sizeof(ULONG)) &&
RtlEqualMemory(pSysBuf + 1, C0CE_SIGNATURE, C0CE_SIGNATURE_SIZE))
{
extended = TRUE;
optsAndBits = *(ULONG *)(pSysBuf + 1 + C0CE_SIGNATURE_SIZE);
#define C0CE_INSERT_OPTS ( \
C0CE_INSERT_IOCTL_GET| \
C0CE_INSERT_IOCTL_RXCLEAR)
#define C0CE_INSERT_BITS ( \
C0CE_INSERT_ENABLE_LSR| \
C0CE_INSERT_ENABLE_MST| \
C0CE_INSERT_ENABLE_RBR| \
C0CE_INSERT_ENABLE_RLC| \
C0CE_INSERT_ENABLE_LSR_BI)
#define C0CE_INSERT_CAPS (C0CE_INSERT_OPTS|C0CE_INSERT_BITS)
if (optsAndBits == C0CE_INSERT_IOCTL_CAPS) {
optsAndBits = 0;
Information += C0CE_SIGNATURE_SIZE + sizeof(ULONG);
if (pIrpStack->Parameters.DeviceIoControl.OutputBufferLength < Information) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
RtlCopyMemory(pSysBuf, C0CE_SIGNATURE, C0CE_SIGNATURE_SIZE);
*(ULONG *)(pSysBuf + C0CE_SIGNATURE_SIZE) = C0CE_INSERT_CAPS;
} else {
if (optsAndBits & ~C0CE_INSERT_CAPS) {
status = STATUS_INVALID_PARAMETER;
break;
}
if (optsAndBits & C0CE_INSERT_IOCTL_GET) {
if (optsAndBits & (C0CE_INSERT_ENABLE_LSR|C0CE_INSERT_ENABLE_LSR_BI))
Information += sizeof(UCHAR)*2 + sizeof(UCHAR);
if (optsAndBits & C0CE_INSERT_ENABLE_MST)
Information += sizeof(UCHAR)*2 + sizeof(UCHAR);
if (optsAndBits & C0CE_INSERT_ENABLE_RBR)
Information += sizeof(UCHAR)*2 + sizeof(ULONG);
if (optsAndBits & C0CE_INSERT_ENABLE_RLC)
Information += sizeof(UCHAR)*2 + sizeof(UCHAR)*3;
}
if (pIrpStack->Parameters.DeviceIoControl.OutputBufferLength < Information) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
}
} else {
extended = FALSE;
optsAndBits = (C0CE_INSERT_ENABLE_LSR|C0CE_INSERT_ENABLE_MST);
}
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
if (escapeChar && ((escapeChar == pIoPortLocal->specialChars.XoffChar) ||
(escapeChar == pIoPortLocal->specialChars.XonChar) ||
(pIoPortLocal->handFlow.FlowReplace & SERIAL_ERROR_CHAR)))
{
status = STATUS_INVALID_PARAMETER;
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
break;
}
pIoPortLocal->insertMask = optsAndBits & C0CE_INSERT_BITS;
pIoPortLocal->escapeChar = escapeChar;
if (extended) {
LIST_ENTRY queueToComplete;
PC0C_IO_PORT pIoPortRemote;
InitializeListHead(&queueToComplete);
pIoPortRemote = pIoPortLocal->pIoPortRemote;
if (optsAndBits & C0CE_INSERT_IOCTL_GET) {
if (optsAndBits & (C0CE_INSERT_ENABLE_LSR|C0CE_INSERT_ENABLE_LSR_BI)) {
UCHAR lsr = 0;
if (C0C_TX_BUFFER_THR_EMPTY(&pIoPortLocal->txBuf)) {
lsr |= 0x20; /* transmit holding register empty */
if (C0C_TX_BUFFER_EMPTY(&pIoPortLocal->txBuf))
lsr |= 0x40; /* transmit holding register empty and line is idle */
}
if ((optsAndBits & C0CE_INSERT_ENABLE_LSR_BI) != 0 && pIoPortLocal->rcvdBreak)
lsr |= 0x10; /* break interrupt indicator */
*pSysBuf++ = escapeChar;
*pSysBuf++ = SERIAL_LSRMST_LSR_NODATA;
*pSysBuf++ = lsr;
}
if (optsAndBits & C0CE_INSERT_ENABLE_MST) {
*pSysBuf++ = escapeChar;
*pSysBuf++ = SERIAL_LSRMST_MST;
*pSysBuf++ = pIoPortLocal->modemStatus;
}
if (optsAndBits & C0CE_INSERT_ENABLE_RBR) {
*pSysBuf++ = escapeChar;
*pSysBuf++ = C0CE_INSERT_RBR;
*(ULONG *)pSysBuf = pIoPortRemote->baudRate.BaudRate;
pSysBuf += sizeof(ULONG);
}
if (optsAndBits & C0CE_INSERT_ENABLE_RLC) {
*pSysBuf++ = escapeChar;
*pSysBuf++ = C0CE_INSERT_RLC;
*pSysBuf++ = pIoPortRemote->lineControl.WordLength;
*pSysBuf++ = pIoPortRemote->lineControl.Parity;
*pSysBuf++ = pIoPortRemote->lineControl.StopBits;
}
}
pIrp->IoStatus.Information = Information;
if (optsAndBits & C0CE_INSERT_IOCTL_RXCLEAR) {
PurgeBuffer(&pIoPortLocal->readBuf);
UpdateHandFlow(pIoPortLocal, TRUE, &queueToComplete);
if (pIoPortLocal->tryWrite || pIoPortRemote->tryWrite) {
ReadWrite(
pIoPortLocal, FALSE,
pIoPortRemote, FALSE,
&queueToComplete);
}
}
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
FdoPortCompleteQueue(&queueToComplete);
TraceIrp("FdoPortIoCtl", pIrp, &status, TRACE_FLAG_RESULTS);
break;
}
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
break;
}
case IOCTL_SERIAL_SET_LINE_CONTROL: {
PSERIAL_LINE_CONTROL pLineControl;
if (pIrpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(SERIAL_LINE_CONTROL)) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
pLineControl = (PSERIAL_LINE_CONTROL)pIrp->AssociatedIrp.SystemBuffer;
switch (pLineControl->WordLength) {
case 5:
case 6:
case 7:
case 8:
break;
default:
status = STATUS_INVALID_PARAMETER;
}
switch (pLineControl->Parity) {
case NO_PARITY:
case ODD_PARITY:
case EVEN_PARITY:
case MARK_PARITY:
case SPACE_PARITY:
break;
default:
status = STATUS_INVALID_PARAMETER;
}
switch (pLineControl->StopBits) {
case STOP_BIT_1:
case STOP_BITS_1_5:
case STOP_BITS_2:
break;
default:
status = STATUS_INVALID_PARAMETER;
}
if (status == STATUS_INVALID_PARAMETER)
break;
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
if (pIoPortLocal->lineControl.StopBits != pLineControl->StopBits ||
pIoPortLocal->lineControl.Parity != pLineControl->Parity ||
pIoPortLocal->lineControl.WordLength != pLineControl->WordLength)
{
PC0C_IO_PORT pIoPortRemote;
pIoPortLocal->lineControl = *pLineControl;
SetWriteDelay(pIoPortLocal);
pIoPortRemote = pIoPortLocal->pIoPortRemote;
if (pIoPortRemote->escapeChar && (pIoPortRemote->insertMask & C0CE_INSERT_ENABLE_RLC)) {
LIST_ENTRY queueToComplete;
InitializeListHead(&queueToComplete);
InsertRemoteLc(pIoPortRemote, &queueToComplete);
if (pIoPortLocal->pIoPortRemote->tryWrite || pIoPortLocal->tryWrite) {
ReadWrite(
pIoPortLocal, FALSE,
pIoPortLocal->pIoPortRemote, FALSE,
&queueToComplete);
}
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
FdoPortCompleteQueue(&queueToComplete);
break;
}
}
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
break;
}
case IOCTL_SERIAL_GET_LINE_CONTROL:
if (pIrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(SERIAL_LINE_CONTROL)) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
*(PSERIAL_LINE_CONTROL)pIrp->AssociatedIrp.SystemBuffer = pIoPortLocal->lineControl;
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
pIrp->IoStatus.Information = sizeof(SERIAL_LINE_CONTROL);
TraceIrp("FdoPortIoCtl", pIrp, &status, TRACE_FLAG_RESULTS);
break;
case IOCTL_SERIAL_SET_BAUD_RATE: {
PSERIAL_BAUD_RATE pBaudRate;
if (pIrpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(SERIAL_BAUD_RATE)) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
pBaudRate = (PSERIAL_BAUD_RATE)pIrp->AssociatedIrp.SystemBuffer;
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
if (pIoPortLocal->baudRate.BaudRate != pBaudRate->BaudRate) {
PC0C_IO_PORT pIoPortRemote;
pIoPortLocal->baudRate = *pBaudRate;
SetWriteDelay(pIoPortLocal);
pIoPortRemote = pIoPortLocal->pIoPortRemote;
if (pIoPortRemote->escapeChar && (pIoPortRemote->insertMask & C0CE_INSERT_ENABLE_RBR)) {
LIST_ENTRY queueToComplete;
InitializeListHead(&queueToComplete);
InsertRemoteBr(pIoPortRemote, &queueToComplete);
if (pIoPortLocal->pIoPortRemote->tryWrite || pIoPortLocal->tryWrite) {
ReadWrite(
pIoPortLocal, FALSE,
pIoPortLocal->pIoPortRemote, FALSE,
&queueToComplete);
}
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
FdoPortCompleteQueue(&queueToComplete);
break;
}
}
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
break;
}
case IOCTL_SERIAL_GET_BAUD_RATE:
if (pIrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(SERIAL_BAUD_RATE)) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
*(PSERIAL_BAUD_RATE)pIrp->AssociatedIrp.SystemBuffer = pIoPortLocal->baudRate;
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
pIrp->IoStatus.Information = sizeof(SERIAL_BAUD_RATE);
TraceIrp("FdoPortIoCtl", pIrp, &status, TRACE_FLAG_RESULTS);
break;
case IOCTL_SERIAL_GET_PROPERTIES: {
ULONG size;
status = GetCommProp(pDevExt,
pIrp->AssociatedIrp.SystemBuffer,
pIrpStack->Parameters.DeviceIoControl.OutputBufferLength,
&size);
if (status == STATUS_SUCCESS) {
pIrp->IoStatus.Information = size;
TraceIrp("FdoPortIoCtl", pIrp, &status, TRACE_FLAG_RESULTS);
}
break;
}
case IOCTL_SERIAL_CONFIG_SIZE:
if (pIrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG)) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
pIrp->IoStatus.Information = sizeof(ULONG);
*(PULONG)pIrp->AssociatedIrp.SystemBuffer = 0;
break;
case IOCTL_SERIAL_SET_QUEUE_SIZE: {
PSERIAL_QUEUE_SIZE pSysBuf = (PSERIAL_QUEUE_SIZE)pIrp->AssociatedIrp.SystemBuffer;
LIST_ENTRY queueToComplete;
PC0C_BUFFER pReadBuf;
PUCHAR pBase;
if (pIrpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(SERIAL_QUEUE_SIZE)) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
pReadBuf = &pIoPortLocal->readBuf;
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
if (pSysBuf->InSize <= C0C_BUFFER_SIZE(pReadBuf)) {
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
break;
}
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
try {
pBase = C0C_ALLOCATE_POOL_WITH_QUOTA(NonPagedPool, pSysBuf->InSize);
}
except (EXCEPTION_EXECUTE_HANDLER) {
pBase = NULL;
status = GetExceptionCode();
}
if (!pBase)
break;
InitializeListHead(&queueToComplete);
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
if (SetNewBufferBase(pReadBuf, pBase, pSysBuf->InSize)) {
pIoPortLocal->handFlow.XoffLimit = pSysBuf->InSize >> 3;
pIoPortLocal->handFlow.XonLimit = pSysBuf->InSize >> 1;
SetLimit(pIoPortLocal);
UpdateHandFlow(pIoPortLocal, TRUE, &queueToComplete);
if (pIoPortLocal->tryWrite || pIoPortLocal->pIoPortRemote->tryWrite) {
ReadWrite(
pIoPortLocal, FALSE,
pIoPortLocal->pIoPortRemote, FALSE,
&queueToComplete);
}
}
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
FdoPortCompleteQueue(&queueToComplete);
break;
}
case IOCTL_SERIAL_GET_STATS:
if (pIrpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(SERIALPERF_STATS)) {
status = STATUS_BUFFER_TOO_SMALL;
break;
}
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
*(PSERIALPERF_STATS)pIrp->AssociatedIrp.SystemBuffer = pIoPortLocal->perfStats;
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
pIrp->IoStatus.Information = sizeof(SERIALPERF_STATS);
TraceIrp("FdoPortIoCtl", pIrp, &status, TRACE_FLAG_RESULTS);
break;
case IOCTL_SERIAL_CLEAR_STATS:
KeAcquireSpinLock(pIoPortLocal->pIoLock, &oldIrql);
RtlZeroMemory(&pIoPortLocal->perfStats, sizeof(pIoPortLocal->perfStats));
KeReleaseSpinLock(pIoPortLocal->pIoLock, oldIrql);
break;
default:
status = STATUS_INVALID_PARAMETER;
}
}
NTSTATUS FdoBusPnp(
IN PC0C_FDOBUS_EXTENSION pDevExt,
IN PIRP pIrp)
{
NTSTATUS status;
PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
ULONG minorFunction = pIrpStack->MinorFunction;
PDEVICE_OBJECT pLowDevObj = pDevExt->pLowDevObj; // IRP_MN_REMOVE_DEVICE deletes *pDevExt!
status = STATUS_SUCCESS;
switch (minorFunction) {
case IRP_MN_QUERY_DEVICE_RELATIONS:
if (pIrpStack->Parameters.QueryDeviceRelations.Type == BusRelations) {
ULONG countPdos, countRelations;
PDEVICE_RELATIONS pRelationsPrev, pRelations;
int i;
countPdos = 0;
for (i = 0 ; i < 2 ; i++) {
if (pDevExt->childs[i].pDevExt)
countPdos++;
}
if (!countPdos)
break;
pRelationsPrev = (PDEVICE_RELATIONS)pIrp->IoStatus.Information;
countRelations = pRelationsPrev ? pRelationsPrev->Count : 0;
pRelations = (PDEVICE_RELATIONS)C0C_ALLOCATE_POOL(PagedPool,
sizeof(DEVICE_RELATIONS) + ((countPdos + countRelations - 1) * sizeof (PDEVICE_OBJECT)));
if (!pRelations) {
status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
if (countRelations)
RtlCopyMemory(pRelations->Objects, pRelationsPrev->Objects,
countRelations * sizeof (PDEVICE_OBJECT));
for (i = 0 ; i < 2 ; i++) {
PC0C_PDOPORT_EXTENSION pPhDevExt;
pPhDevExt = pDevExt->childs[i].pDevExt;
if (pPhDevExt) {
if (!pDevExt->childs[i].ioPort.pDevExt) {
UNICODE_STRING portName;
UNICODE_STRING portRegistryPath;
RtlInitUnicodeString(&portRegistryPath, NULL);
StrAppendPortParametersRegistryPath(&status, &portRegistryPath, pPhDevExt->portName);
RtlInitUnicodeString(&portName, NULL);
StrAppendParameterPortName(&status, &portName, portRegistryPath.Buffer);
StrFree(&portRegistryPath);
if (NT_SUCCESS(status) && portName.Length &&
_wcsicmp(C0C_PORT_NAME_COMCLASS, portName.Buffer) == 0)
{
pDevExt->childs[i].ioPort.isComClass = TRUE;
Trace0((PC0C_COMMON_EXTENSION)pPhDevExt, L"Port class set to COM");
} else {
pDevExt->childs[i].ioPort.isComClass = FALSE;
Trace0((PC0C_COMMON_EXTENSION)pPhDevExt, L"Port class set to CNC");
}
StrFree(&portName);
status = STATUS_SUCCESS;
}
pRelations->Objects[countRelations++] = pPhDevExt->pDevObj;
ObReferenceObject(pPhDevExt->pDevObj);
}
}
pRelations->Count = countRelations;
if (pRelationsPrev)
ExFreePool(pRelationsPrev);
pIrp->IoStatus.Information = (ULONG_PTR)pRelations;
pIrp->IoStatus.Status = STATUS_SUCCESS;
}
break;
case IRP_MN_REMOVE_DEVICE:
RemoveFdoBus(pDevExt);
pDevExt = NULL;
pIrp->IoStatus.Status = STATUS_SUCCESS;
break;
case IRP_MN_START_DEVICE:
case IRP_MN_STOP_DEVICE:
case IRP_MN_QUERY_STOP_DEVICE:
case IRP_MN_CANCEL_STOP_DEVICE:
case IRP_MN_QUERY_REMOVE_DEVICE:
case IRP_MN_CANCEL_REMOVE_DEVICE:
case IRP_MN_SURPRISE_REMOVAL:
pIrp->IoStatus.Status = STATUS_SUCCESS;
break;
}
if (status == STATUS_SUCCESS) {
TraceIrp("FdoBusPnp", pIrp, NULL, TRACE_FLAG_RESULTS);
IoSkipCurrentIrpStackLocation(pIrp);
status = IoCallDriver(pLowDevObj, pIrp);
TraceCode((PC0C_COMMON_EXTENSION)pDevExt, "PNP ", codeNameTablePnp, minorFunction, &status);
} else {
TraceIrp("PNP", pIrp, &status, TRACE_FLAG_RESULTS);
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
}
return status;
}
NTSTATUS FdoPortPnp(
IN PC0C_FDOPORT_EXTENSION pDevExt,
IN PIRP pIrp)
{
NTSTATUS status;
PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
ULONG minorFunction = pIrpStack->MinorFunction;
PDEVICE_OBJECT pLowDevObj = pDevExt->pLowDevObj; // IRP_MN_REMOVE_DEVICE deletes *pDevExt!
status = STATUS_SUCCESS;
switch (minorFunction) {
case IRP_MN_QUERY_DEVICE_RELATIONS: {
LIST_ENTRY queueToComplete;
KIRQL oldIrql;
PC0C_IO_PORT pIoPort = pDevExt->pIoPortLocal;
if ((pIoPort->exclusiveMode && pIoPort->isOpen) ||
(pIoPort->plugInMode && !pIoPort->pIoPortRemote->isOpen))
{
HidePort(pDevExt);
} else {
ShowPort(pDevExt);
}
/* complete pending CLOSE IRPs */
InitializeListHead(&queueToComplete);
KeAcquireSpinLock(pIoPort->pIoLock, &oldIrql);
FdoPortIo(C0C_IO_TYPE_CLOSE_COMPLETE,
NULL,
pIoPort,
&pIoPort->irpQueues[C0C_QUEUE_CLOSE],
&queueToComplete);
KeReleaseSpinLock(pIoPort->pIoLock, oldIrql);
FdoPortCompleteQueue(&queueToComplete);
break;
}
case IRP_MN_QUERY_REMOVE_DEVICE:
if (pDevExt->openCount)
status = STATUS_DEVICE_BUSY;
else
pIrp->IoStatus.Status = STATUS_SUCCESS;
break;
case IRP_MN_REMOVE_DEVICE:
RemoveFdoPort(pDevExt);
pDevExt = NULL;
pIrp->IoStatus.Status = STATUS_SUCCESS;
break;
case IRP_MN_START_DEVICE:
case IRP_MN_STOP_DEVICE:
case IRP_MN_QUERY_STOP_DEVICE:
case IRP_MN_CANCEL_STOP_DEVICE:
case IRP_MN_SURPRISE_REMOVAL:
pIrp->IoStatus.Status = STATUS_SUCCESS;
break;
}
if (status == STATUS_SUCCESS) {
IoSkipCurrentIrpStackLocation(pIrp);
status = IoCallDriver(pLowDevObj, pIrp);
TraceCode((PC0C_COMMON_EXTENSION)pDevExt, "PNP ", codeNameTablePnp, minorFunction, &status);
} else {
TraceIrp("PNP", pIrp, &status, TRACE_FLAG_RESULTS);
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
}
return status;
}
NTSTATUS PdoPortPnp(
IN PC0C_PDOPORT_EXTENSION pDevExt,
IN PIRP pIrp)
{
NTSTATUS status = pIrp->IoStatus.Status;
PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
switch (pIrpStack->MinorFunction) {
case IRP_MN_QUERY_ID:
status = PdoPortQueryId(pDevExt, pIrp, pIrpStack);
break;
case IRP_MN_QUERY_CAPABILITIES:
status = PdoPortQueryCaps(pDevExt, pIrp, pIrpStack);
break;
case IRP_MN_QUERY_DEVICE_TEXT:
status = PdoPortQueryDevText(pDevExt, pIrp, pIrpStack);
break;
case IRP_MN_QUERY_BUS_INFORMATION:
status = PdoPortBusInfo(pDevExt, pIrp);
break;
case IRP_MN_QUERY_DEVICE_RELATIONS:
switch (pIrpStack->Parameters.QueryDeviceRelations.Type) {
case TargetDeviceRelation: {
PDEVICE_RELATIONS pRelations;
HALT_UNLESS(pIrp->IoStatus.Information == 0);
if (pIrp->IoStatus.Information != 0)
break;
pRelations = (PDEVICE_RELATIONS)C0C_ALLOCATE_POOL(PagedPool, sizeof(DEVICE_RELATIONS));
if (!pRelations) {
status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
pRelations->Count = 1;
pRelations->Objects[0] = pDevExt->pDevObj;
ObReferenceObject(pDevExt->pDevObj);
pIrp->IoStatus.Information = (ULONG_PTR)pRelations;
status = STATUS_SUCCESS;
break;
}
case RemovalRelations:
case BusRelations:
case EjectionRelations:
case PowerRelations:
default:
break;
}
break;
case IRP_MN_DEVICE_USAGE_NOTIFICATION:
status = STATUS_UNSUCCESSFUL;
break;
case IRP_MN_REMOVE_DEVICE:
case IRP_MN_START_DEVICE:
case IRP_MN_STOP_DEVICE:
case IRP_MN_QUERY_STOP_DEVICE:
case IRP_MN_CANCEL_STOP_DEVICE:
case IRP_MN_QUERY_REMOVE_DEVICE:
case IRP_MN_CANCEL_REMOVE_DEVICE:
case IRP_MN_SURPRISE_REMOVAL:
case IRP_MN_EJECT:
status = STATUS_SUCCESS;
break;
default:
break;
}
TraceIrp("PNP", pIrp, &status, TRACE_FLAG_RESULTS);
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
return status;
}
