📄 ioctl.c
字号:
}
if (Extension->RXHolding & SERIAL_RX_XOFF) {
Stat->HoldReasons |= SERIAL_TX_WAITING_XOFF_SENT;
}
return FALSE;
}
BOOLEAN
SerialSetEscapeChar(
IN PVOID Context
)
/*++
Routine Description:
This is used to set the character that will be used to escape
line status and modem status information when the application
has set up that line status and modem status should be passed
back in the data stream.
Arguments:
Context - Pointer to the irp that is specify the escape character.
Implicitly - An escape character of 0 means no escaping
will occur.
Return Value:
This routine always returns FALSE.
--*/
{
PSERIAL_DEVICE_EXTENSION extension =
IoGetCurrentIrpStackLocation((PIRP)Context)
->DeviceObject->DeviceExtension;
extension->EscapeChar =
*(PUCHAR)((PIRP)Context)->AssociatedIrp.SystemBuffer;
return FALSE;
}
NTSTATUS
SerialIoControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine provides the initial processing for all of the
Ioctrls for the serial device.
Arguments:
DeviceObject - Pointer to the device object for this device
Irp - Pointer to the IRP for the current request
Return Value:
The function value is the final status of the call
--*/
{
//
// The status that gets returned to the caller and
// set in the Irp.
//
NTSTATUS Status;
//
// The current stack location. This contains all of the
// information we need to process this particular request.
//
PIO_STACK_LOCATION IrpSp;
//
// Just what it says. This is the serial specific device
// extension of the device object create for the serial driver.
//
PSERIAL_DEVICE_EXTENSION Extension = DeviceObject->DeviceExtension;
//
// A temporary to hold the old IRQL so that it can be
// restored once we complete/validate this request.
//
KIRQL OldIrql;
NTSTATUS prologueStatus;
SERIAL_LOCKED_PAGED_CODE();
//
// We expect to be open so all our pages are locked down. This is, after
// all, an IO operation, so the device should be open first.
//
if (Extension->DeviceIsOpened != TRUE) {
Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_INVALID_DEVICE_REQUEST;
}
if ((prologueStatus = SerialIRPPrologue(Irp, Extension))
!= STATUS_SUCCESS) {
if(prologueStatus != STATUS_PENDING) {
Irp->IoStatus.Status = prologueStatus;
SerialCompleteRequest(Extension, Irp, IO_NO_INCREMENT);
}
return prologueStatus;
}
SerialDbgPrintEx(SERIRPPATH, "Dispatch entry for: %x\n", Irp);
if (SerialCompleteIfError(
DeviceObject,
Irp
) != STATUS_SUCCESS) {
return STATUS_CANCELLED;
}
IrpSp = IoGetCurrentIrpStackLocation(Irp);
Irp->IoStatus.Information = 0L;
Status = STATUS_SUCCESS;
switch (IrpSp->Parameters.DeviceIoControl.IoControlCode) {
case IOCTL_SERIAL_SET_BAUD_RATE : {
ULONG BaudRate;
//
// Will hold the value of the appropriate divisor for
// the requested baud rate. If the baudrate is invalid
// (because the device won't support that baud rate) then
// this value is undefined.
//
// Note: in one sense the concept of a valid baud rate
// is cloudy. We could allow the user to request any
// baud rate. We could then calculate the divisor needed
// for that baud rate. As long as the divisor wasn't less
// than one we would be "ok". (The percentage difference
// between the "true" divisor and the "rounded" value given
// to the hardware might make it unusable, but... ) It would
// really be up to the user to "Know" whether the baud rate
// is suitable. So much for theory, *We* only support a given
// set of baud rates.
//
SHORT AppropriateDivisor;
if (IrpSp->Parameters.DeviceIoControl.InputBufferLength <
sizeof(SERIAL_BAUD_RATE)) {
Status = STATUS_BUFFER_TOO_SMALL;
break;
} else {
BaudRate = ((PSERIAL_BAUD_RATE)(Irp->AssociatedIrp.SystemBuffer))->BaudRate;
}
//
// Get the baud rate from the irp. We pass it
// to a routine which will set the correct divisor.
//
Status = SerialGetDivisorFromBaud(
Extension->ClockRate,
BaudRate,
&AppropriateDivisor
);
//
// Make sure we are at power D0
//
if (NT_SUCCESS(Status)) {
if (Extension->PowerState != PowerDeviceD0) {
Status = SerialGotoPowerState(Extension->Pdo, Extension,
PowerDeviceD0);
if (!NT_SUCCESS(Status)) {
break;
}
}
}
KeAcquireSpinLock(
&Extension->ControlLock,
&OldIrql
);
if (NT_SUCCESS(Status)) {
SERIAL_IOCTL_SYNC S;
Extension->CurrentBaud = BaudRate;
Extension->WmiCommData.BaudRate = BaudRate;
S.Extension = Extension;
S.Data = (PVOID)AppropriateDivisor;
KeSynchronizeExecution(
Extension->Interrupt,
SerialSetBaud,
&S
);
}
KeReleaseSpinLock(
&Extension->ControlLock,
OldIrql
);
break;
}
case IOCTL_SERIAL_GET_BAUD_RATE: {
PSERIAL_BAUD_RATE Br = (PSERIAL_BAUD_RATE)Irp->AssociatedIrp.SystemBuffer;
if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength <
sizeof(SERIAL_BAUD_RATE)) {
Status = STATUS_BUFFER_TOO_SMALL;
break;
}
KeAcquireSpinLock(
&Extension->ControlLock,
&OldIrql
);
Br->BaudRate = Extension->CurrentBaud;
KeReleaseSpinLock(
&Extension->ControlLock,
OldIrql
);
Irp->IoStatus.Information = sizeof(SERIAL_BAUD_RATE);
break;
}
case IOCTL_SERIAL_GET_MODEM_CONTROL: {
SERIAL_IOCTL_SYNC S;
if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength <
sizeof(ULONG)) {
Status = STATUS_BUFFER_TOO_SMALL;
break;
}
Irp->IoStatus.Information = sizeof(ULONG);
S.Extension = Extension;
S.Data = Irp->AssociatedIrp.SystemBuffer;
KeAcquireSpinLock(
&Extension->ControlLock,
&OldIrql
);
KeSynchronizeExecution(
Extension->Interrupt,
SerialGetMCRContents,
&S
);
KeReleaseSpinLock(
&Extension->ControlLock,
OldIrql
);
break;
}
case IOCTL_SERIAL_SET_MODEM_CONTROL: {
SERIAL_IOCTL_SYNC S;
if (IrpSp->Parameters.DeviceIoControl.InputBufferLength <
sizeof(ULONG)) {
Status = STATUS_BUFFER_TOO_SMALL;
break;
}
S.Extension = Extension;
S.Data = Irp->AssociatedIrp.SystemBuffer;
//
// Make sure we are at power D0
//
if (Extension->PowerState != PowerDeviceD0) {
Status = SerialGotoPowerState(Extension->Pdo, Extension,
PowerDeviceD0);
if (!NT_SUCCESS(Status)) {
break;
}
}
KeAcquireSpinLock(
&Extension->ControlLock,
&OldIrql
);
KeSynchronizeExecution(
Extension->Interrupt,
SerialSetMCRContents,
&S
);
KeReleaseSpinLock(
&Extension->ControlLock,
OldIrql
);
break;
}
case IOCTL_SERIAL_SET_FIFO_CONTROL: {
SERIAL_IOCTL_SYNC S;
if (IrpSp->Parameters.DeviceIoControl.InputBufferLength <
sizeof(ULONG)) {
Status = STATUS_BUFFER_TOO_SMALL;
break;
}
S.Extension = Extension;
S.Data = Irp->AssociatedIrp.SystemBuffer;
//
// Make sure we are at power D0
//
if (Extension->PowerState != PowerDeviceD0) {
Status = SerialGotoPowerState(Extension->Pdo, Extension,
PowerDeviceD0);
if (!NT_SUCCESS(Status)) {
break;
}
}
KeAcquireSpinLock(
&Extension->ControlLock,
&OldIrql
);
KeSynchronizeExecution(
Extension->Interrupt,
SerialSetFCRContents,
&S
);
KeReleaseSpinLock(
&Extension->ControlLock,
OldIrql
);
break;
}
case IOCTL_SERIAL_SET_LINE_CONTROL: {
//
// Points to the line control record in the Irp.
//
PSERIAL_LINE_CONTROL Lc =
((PSERIAL_LINE_CONTROL)(Irp->AssociatedIrp.SystemBuffer));
UCHAR LData;
UCHAR LStop;
UCHAR LParity;
UCHAR Mask = 0xff;
if (IrpSp->Parameters.DeviceIoControl.InputBufferLength <
sizeof(SERIAL_LINE_CONTROL)) {
Status = STATUS_BUFFER_TOO_SMALL;
break;
}
//
// Make sure we are at power D0
//
if (Extension->PowerState != PowerDeviceD0) {
Status = SerialGotoPowerState(Extension->Pdo, Extension,
PowerDeviceD0);
if (!NT_SUCCESS(Status)) {
break;
}
}
switch (Lc->WordLength) {
case 5: {
LData = SERIAL_5_DATA;
Mask = 0x1f;
break;
}
case 6: {
LData = SERIAL_6_DATA;
Mask = 0x3f;
break;
}
case 7: {
LData = SERIAL_7_DATA;
Mask = 0x7f;
break;
}
case 8: {
LData = SERIAL_8_DATA;
break;
}
default: {
Status = STATUS_INVALID_PARAMETER;
goto DoneWithIoctl;
}
}
Extension->WmiCommData.BitsPerByte = Lc->WordLength;
switch (Lc->Parity) {
case NO_PARITY: {
Extension->WmiCommData.Parity = SERIAL_WMI_PARITY_NONE;
LParity = SERIAL_NONE_PARITY;
break;
}
case EVEN_PARITY: {
Extension->WmiCommData.Parity = SERIAL_WMI_PARITY_EVEN;
LParity = SERIAL_EVEN_PARITY;
break;
}
case ODD_PARITY: {
Extension->WmiCommData.Parity = SERIAL_WMI_PARITY_ODD;
LParity = SERIAL_ODD_PARITY;
break;
}
case SPACE_PARITY: {
Extension->WmiCommData.Parity = SERIAL_WMI_PARITY_SPACE;
LParity = SERIAL_SPACE_PARITY;
break;
}
case MARK_PARITY: {
Extension->WmiCommData.Parity = SERIAL_WMI_PARITY_MARK;
LParity = SERIAL_MARK_PARITY;
break;
}
default: {
Status = STATUS_INVALID_PARAMETER;
goto DoneWithIoctl;
break;
}
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -