1118 lines
28 KiB
C
1118 lines
28 KiB
C
/*++
|
||
|
||
Copyright (c) 1993 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
parvdm.c
|
||
|
||
Abstract:
|
||
|
||
This module contains the code for a simple parallel class driver.
|
||
|
||
Unload and Cleanup are supported. The model for grabing and
|
||
releasing the parallel port is embodied in the code for IRP_MJ_READ.
|
||
Other IRP requests could be implemented similarly.
|
||
|
||
Basically, every READ requests that comes in gets
|
||
passed down to the port driver as a parallel port allocate
|
||
request. This IRP will return to this driver when the driver
|
||
|
||
Author:
|
||
|
||
Norbert P. Kusters 25-Jan-1994
|
||
|
||
Environment:
|
||
|
||
Kernel mode
|
||
|
||
Revision History :
|
||
|
||
--*/
|
||
|
||
#include "dderror.h"
|
||
#include "ntos.h"
|
||
#include "parallel.h"
|
||
#include "ntddvdm.h"
|
||
#include "parvdm.h"
|
||
#include "parlog.h"
|
||
|
||
static const PHYSICAL_ADDRESS PhysicalZero = {0};
|
||
|
||
NTSTATUS
|
||
DriverEntry(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN PUNICODE_STRING RegistryPath
|
||
);
|
||
|
||
BOOLEAN
|
||
ParMakeNames(
|
||
IN ULONG ParallelPortNumber,
|
||
OUT PUNICODE_STRING PortName,
|
||
OUT PUNICODE_STRING ClassName,
|
||
OUT PUNICODE_STRING LinkName
|
||
);
|
||
|
||
VOID
|
||
ParInitializeDeviceObject(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN ULONG ParallelPortNumber
|
||
);
|
||
|
||
NTSTATUS
|
||
ParGetPortInfoFromPortDevice(
|
||
IN OUT PDEVICE_EXTENSION Extension
|
||
);
|
||
|
||
VOID
|
||
ParReleasePortInfoToPortDevice(
|
||
IN OUT PDEVICE_EXTENSION Extension
|
||
);
|
||
|
||
NTSTATUS
|
||
ParAllocPort(
|
||
IN PDEVICE_EXTENSION Extension,
|
||
IN PIRP Irp
|
||
);
|
||
|
||
VOID
|
||
ParLogError(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN PDEVICE_OBJECT DeviceObject OPTIONAL,
|
||
IN PHYSICAL_ADDRESS P1,
|
||
IN PHYSICAL_ADDRESS P2,
|
||
IN ULONG SequenceNumber,
|
||
IN UCHAR MajorFunctionCode,
|
||
IN UCHAR RetryCount,
|
||
IN ULONG UniqueErrorValue,
|
||
IN NTSTATUS FinalStatus,
|
||
IN NTSTATUS SpecificIOStatus
|
||
);
|
||
#ifdef ALLOC_PRAGMA
|
||
#pragma alloc_text(INIT,DriverEntry)
|
||
#pragma alloc_text(INIT,ParInitializeDeviceObject)
|
||
#pragma alloc_text(INIT,ParMakeNames)
|
||
#endif
|
||
//
|
||
// Keep track of OPEN and CLOSE.
|
||
//
|
||
ULONG OpenCloseReferenceCount = 1;
|
||
PFAST_MUTEX OpenCloseMutex = NULL;
|
||
|
||
#define ParClaimDriver() \
|
||
ExAcquireFastMutex(OpenCloseMutex); \
|
||
if(++OpenCloseReferenceCount == 1) { \
|
||
MmResetDriverPaging(DriverEntry); \
|
||
} \
|
||
ExReleaseFastMutex(OpenCloseMutex); \
|
||
|
||
#define ParReleaseDriver() \
|
||
ExAcquireFastMutex(OpenCloseMutex); \
|
||
if(--OpenCloseReferenceCount == 0) { \
|
||
MmPageEntireDriver(DriverEntry); \
|
||
} \
|
||
ExReleaseFastMutex(OpenCloseMutex); \
|
||
|
||
|
||
NTSTATUS
|
||
DriverEntry(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN PUNICODE_STRING RegistryPath
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called at system initialization time to initialize
|
||
this driver.
|
||
|
||
Arguments:
|
||
|
||
DriverObject - Supplies the driver object.
|
||
|
||
RegistryPath - Supplies the registry path for this driver.
|
||
|
||
Return Value:
|
||
|
||
STATUS_SUCCESS - We could initialize at least one device.
|
||
STATUS_NO_SUCH_DEVICE - We could not initialize even one device.
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG i;
|
||
|
||
//
|
||
// allocate the mutex to protect driver reference count
|
||
//
|
||
|
||
OpenCloseMutex = ExAllocatePool(NonPagedPool, sizeof(FAST_MUTEX));
|
||
if (!OpenCloseMutex) {
|
||
|
||
//
|
||
// NOTE - we could probably do without bailing here and just
|
||
// leave a note for ourselves to never page out, but since we
|
||
// don't have enough memory to allocate a mutex we should probably
|
||
// avoid leaving the driver paged in at all times
|
||
//
|
||
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
ExInitializeFastMutex(OpenCloseMutex);
|
||
|
||
|
||
for (i = 0; i < IoGetConfigurationInformation()->ParallelCount; i++) {
|
||
ParInitializeDeviceObject(DriverObject, i);
|
||
}
|
||
|
||
if (!DriverObject->DeviceObject) {
|
||
return STATUS_NO_SUCH_DEVICE;
|
||
}
|
||
|
||
//
|
||
// Initialize the Driver Object with driver's entry points
|
||
//
|
||
|
||
DriverObject->MajorFunction[IRP_MJ_CREATE] = ParCreateOpen;
|
||
DriverObject->MajorFunction[IRP_MJ_CLOSE] = ParClose;
|
||
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ParDeviceControl;
|
||
DriverObject->DriverUnload = ParUnload;
|
||
|
||
//
|
||
// page out the driver if we can
|
||
//
|
||
|
||
ParReleaseDriver();
|
||
|
||
|
||
return STATUS_SUCCESS;
|
||
}
|
||
|
||
VOID
|
||
ParLogError(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN PDEVICE_OBJECT DeviceObject OPTIONAL,
|
||
IN PHYSICAL_ADDRESS P1,
|
||
IN PHYSICAL_ADDRESS P2,
|
||
IN ULONG SequenceNumber,
|
||
IN UCHAR MajorFunctionCode,
|
||
IN UCHAR RetryCount,
|
||
IN ULONG UniqueErrorValue,
|
||
IN NTSTATUS FinalStatus,
|
||
IN NTSTATUS SpecificIOStatus
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine allocates an error log entry, copies the supplied data
|
||
to it, and requests that it be written to the error log file.
|
||
|
||
Arguments:
|
||
|
||
DriverObject - Supplies a pointer to the driver object for the
|
||
device.
|
||
|
||
DeviceObject - Supplies a pointer to the device object associated
|
||
with the device that had the error, early in
|
||
initialization, one may not yet exist.
|
||
|
||
P1,P2 - Supplies the physical addresses for the controller
|
||
ports involved with the error if they are available
|
||
and puts them through as dump data.
|
||
|
||
SequenceNumber - Supplies a ulong value that is unique to an IRP over
|
||
the life of the irp in this driver - 0 generally
|
||
means an error not associated with an irp.
|
||
|
||
MajorFunctionCode - Supplies the major function code of the irp if there
|
||
is an error associated with it.
|
||
|
||
RetryCount - Supplies the number of times a particular operation
|
||
has been retried.
|
||
|
||
UniqueErrorValue - Supplies a unique long word that identifies the
|
||
particular call to this function.
|
||
|
||
FinalStatus - Supplies the final status given to the irp that was
|
||
associated with this error. If this log entry is
|
||
being made during one of the retries this value
|
||
will be STATUS_SUCCESS.
|
||
|
||
SpecificIOStatus - Supplies the IO status for this particular error.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
PIO_ERROR_LOG_PACKET errorLogEntry;
|
||
PVOID objectToUse;
|
||
SHORT dumpToAllocate;
|
||
|
||
if (ARGUMENT_PRESENT(DeviceObject)) {
|
||
objectToUse = DeviceObject;
|
||
} else {
|
||
objectToUse = DriverObject;
|
||
}
|
||
|
||
dumpToAllocate = 0;
|
||
|
||
if (P1.LowPart != 0 || P1.HighPart != 0) {
|
||
dumpToAllocate = (SHORT) sizeof(PHYSICAL_ADDRESS);
|
||
}
|
||
|
||
if (P2.LowPart != 0 || P2.HighPart != 0) {
|
||
dumpToAllocate += (SHORT) sizeof(PHYSICAL_ADDRESS);
|
||
}
|
||
|
||
errorLogEntry = IoAllocateErrorLogEntry(objectToUse,
|
||
(UCHAR) (sizeof(IO_ERROR_LOG_PACKET) + dumpToAllocate));
|
||
|
||
if (!errorLogEntry) {
|
||
return;
|
||
}
|
||
|
||
errorLogEntry->ErrorCode = SpecificIOStatus;
|
||
errorLogEntry->SequenceNumber = SequenceNumber;
|
||
errorLogEntry->MajorFunctionCode = MajorFunctionCode;
|
||
errorLogEntry->RetryCount = RetryCount;
|
||
errorLogEntry->UniqueErrorValue = UniqueErrorValue;
|
||
errorLogEntry->FinalStatus = FinalStatus;
|
||
errorLogEntry->DumpDataSize = dumpToAllocate;
|
||
|
||
if (dumpToAllocate) {
|
||
|
||
RtlCopyMemory(errorLogEntry->DumpData, &P1, sizeof(PHYSICAL_ADDRESS));
|
||
|
||
if (dumpToAllocate > sizeof(PHYSICAL_ADDRESS)) {
|
||
|
||
RtlCopyMemory(((PUCHAR) errorLogEntry->DumpData) +
|
||
sizeof(PHYSICAL_ADDRESS), &P2,
|
||
sizeof(PHYSICAL_ADDRESS));
|
||
}
|
||
}
|
||
|
||
IoWriteErrorLogEntry(errorLogEntry);
|
||
}
|
||
|
||
VOID
|
||
ParInitializeDeviceObject(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN ULONG ParallelPortNumber
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called for every parallel port in the system. It
|
||
will create a class device upon connecting to the port device
|
||
corresponding to it.
|
||
|
||
Arguments:
|
||
|
||
DriverObject - Supplies the driver object.
|
||
|
||
ParallelPortNumber - Supplies the number for this port.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
UNICODE_STRING portName, className, linkName;
|
||
NTSTATUS status;
|
||
PDEVICE_OBJECT deviceObject;
|
||
PDEVICE_EXTENSION extension;
|
||
PFILE_OBJECT fileObject;
|
||
|
||
|
||
// Cobble together the port and class device names.
|
||
|
||
if (!ParMakeNames(ParallelPortNumber, &portName, &className, &linkName)) {
|
||
|
||
ParLogError(DriverObject, NULL, PhysicalZero, PhysicalZero, 0, 0, 0, 1,
|
||
STATUS_SUCCESS, PAR_INSUFFICIENT_RESOURCES);
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
// Create the device object.
|
||
|
||
status = IoCreateDevice(DriverObject, sizeof(DEVICE_EXTENSION),
|
||
&className, FILE_DEVICE_PARALLEL_PORT, 0, FALSE,
|
||
&deviceObject);
|
||
if (!NT_SUCCESS(status)) {
|
||
|
||
ParLogError(DriverObject, NULL, PhysicalZero, PhysicalZero, 0, 0, 0, 2,
|
||
STATUS_SUCCESS, PAR_INSUFFICIENT_RESOURCES);
|
||
|
||
ExFreePool(linkName.Buffer);
|
||
goto Cleanup;
|
||
}
|
||
|
||
|
||
// Now that the device has been created,
|
||
// set up the device extension.
|
||
|
||
extension = deviceObject->DeviceExtension;
|
||
RtlZeroMemory(extension, sizeof(DEVICE_EXTENSION));
|
||
|
||
extension->DeviceObject = deviceObject;
|
||
deviceObject->Flags |= DO_BUFFERED_IO;
|
||
|
||
status = IoGetDeviceObjectPointer(&portName, FILE_READ_ATTRIBUTES,
|
||
&fileObject,
|
||
&extension->PortDeviceObject);
|
||
if (!NT_SUCCESS(status)) {
|
||
|
||
ParLogError(DriverObject, deviceObject, PhysicalZero, PhysicalZero,
|
||
0, 0, 0, 3, STATUS_SUCCESS, PAR_CANT_FIND_PORT_DRIVER);
|
||
|
||
IoDeleteDevice(deviceObject);
|
||
ExFreePool(linkName.Buffer);
|
||
goto Cleanup;
|
||
}
|
||
|
||
ObDereferenceObject(fileObject);
|
||
|
||
extension->DeviceObject->StackSize =
|
||
extension->PortDeviceObject->StackSize + 1;
|
||
|
||
|
||
// We don't own parallel ports initially
|
||
|
||
extension->PortOwned = FALSE;
|
||
|
||
// Get the port information from the port device object.
|
||
|
||
status = ParGetPortInfoFromPortDevice(extension);
|
||
if (!NT_SUCCESS(status)) {
|
||
|
||
ParLogError(DriverObject, deviceObject, PhysicalZero, PhysicalZero,
|
||
0, 0, 0, 4, STATUS_SUCCESS, PAR_CANT_FIND_PORT_DRIVER);
|
||
|
||
IoDeleteDevice(deviceObject);
|
||
ExFreePool(linkName.Buffer);
|
||
goto Cleanup;
|
||
}
|
||
|
||
|
||
// Set up the symbolic link for windows apps.
|
||
|
||
status = IoCreateUnprotectedSymbolicLink(&linkName, &className);
|
||
if (!NT_SUCCESS(status)) {
|
||
|
||
ParLogError(DriverObject, deviceObject, extension->OriginalController,
|
||
PhysicalZero, 0, 0, 0, 5, STATUS_SUCCESS,
|
||
PAR_NO_SYMLINK_CREATED);
|
||
|
||
extension->CreatedSymbolicLink = FALSE;
|
||
ExFreePool(linkName.Buffer);
|
||
goto Cleanup;
|
||
}
|
||
|
||
|
||
// We were able to create the symbolic link, so record this
|
||
// value in the extension for cleanup at unload time.
|
||
|
||
extension->CreatedSymbolicLink = TRUE;
|
||
extension->SymbolicLinkName = linkName;
|
||
|
||
Cleanup:
|
||
// release the port info so the port driver can be paged out
|
||
ParReleasePortInfoToPortDevice(extension);
|
||
ExFreePool(portName.Buffer);
|
||
ExFreePool(className.Buffer);
|
||
}
|
||
|
||
BOOLEAN
|
||
ParMakeNames(
|
||
IN ULONG ParallelPortNumber,
|
||
OUT PUNICODE_STRING PortName,
|
||
OUT PUNICODE_STRING ClassName,
|
||
OUT PUNICODE_STRING LinkName
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine generates the names \Device\ParallelPortN and
|
||
\Device\ParallelVdmN, \DosDevices\PARVDMN.
|
||
|
||
Arguments:
|
||
|
||
ParallelPortNumber - Supplies the port number.
|
||
|
||
PortName - Returns the port name.
|
||
|
||
ClassName - Returns the class name.
|
||
|
||
LinkName - Returns the symbolic link name.
|
||
|
||
Return Value:
|
||
|
||
FALSE - Failure.
|
||
TRUE - Success.
|
||
|
||
--*/
|
||
{
|
||
UNICODE_STRING prefix, digits, linkPrefix, linkDigits;
|
||
WCHAR digitsBuffer[10], linkDigitsBuffer[10];
|
||
UNICODE_STRING portSuffix, classSuffix, linkSuffix;
|
||
NTSTATUS status;
|
||
|
||
// Put together local variables for constructing names.
|
||
|
||
RtlInitUnicodeString(&prefix, L"\\Device\\");
|
||
RtlInitUnicodeString(&linkPrefix, L"\\DosDevices\\");
|
||
RtlInitUnicodeString(&portSuffix, DD_PARALLEL_PORT_BASE_NAME_U);
|
||
RtlInitUnicodeString(&classSuffix, L"ParallelVdm");
|
||
RtlInitUnicodeString(&linkSuffix, L"$VDMLPT");
|
||
digits.Length = 0;
|
||
digits.MaximumLength = 20;
|
||
digits.Buffer = digitsBuffer;
|
||
linkDigits.Length = 0;
|
||
linkDigits.MaximumLength = 20;
|
||
linkDigits.Buffer = linkDigitsBuffer;
|
||
status = RtlIntegerToUnicodeString(ParallelPortNumber, 10, &digits);
|
||
if (!NT_SUCCESS(status)) {
|
||
return FALSE;
|
||
}
|
||
status = RtlIntegerToUnicodeString(ParallelPortNumber + 1, 10, &linkDigits);
|
||
if (!NT_SUCCESS(status)) {
|
||
return FALSE;
|
||
}
|
||
|
||
// Make the port name.
|
||
|
||
PortName->Length = 0;
|
||
PortName->MaximumLength = prefix.Length + portSuffix.Length +
|
||
digits.Length + sizeof(WCHAR);
|
||
PortName->Buffer = ExAllocatePool(PagedPool, PortName->MaximumLength);
|
||
if (!PortName->Buffer) {
|
||
return FALSE;
|
||
}
|
||
RtlZeroMemory(PortName->Buffer, PortName->MaximumLength);
|
||
RtlAppendUnicodeStringToString(PortName, &prefix);
|
||
RtlAppendUnicodeStringToString(PortName, &portSuffix);
|
||
RtlAppendUnicodeStringToString(PortName, &digits);
|
||
|
||
|
||
// Make the class name.
|
||
|
||
ClassName->Length = 0;
|
||
ClassName->MaximumLength = prefix.Length + classSuffix.Length +
|
||
digits.Length + sizeof(WCHAR);
|
||
ClassName->Buffer = ExAllocatePool(PagedPool, ClassName->MaximumLength);
|
||
if (!ClassName->Buffer) {
|
||
ExFreePool(PortName->Buffer);
|
||
return FALSE;
|
||
}
|
||
RtlZeroMemory(ClassName->Buffer, ClassName->MaximumLength);
|
||
RtlAppendUnicodeStringToString(ClassName, &prefix);
|
||
RtlAppendUnicodeStringToString(ClassName, &classSuffix);
|
||
RtlAppendUnicodeStringToString(ClassName, &digits);
|
||
|
||
|
||
// Make the link name.
|
||
|
||
LinkName->Length = 0;
|
||
LinkName->MaximumLength = linkPrefix.Length + linkSuffix.Length +
|
||
linkDigits.Length + sizeof(WCHAR);
|
||
LinkName->Buffer = ExAllocatePool(PagedPool, LinkName->MaximumLength);
|
||
if (!LinkName->Buffer) {
|
||
ExFreePool(PortName->Buffer);
|
||
ExFreePool(ClassName->Buffer);
|
||
return FALSE;
|
||
}
|
||
RtlZeroMemory(LinkName->Buffer, LinkName->MaximumLength);
|
||
RtlAppendUnicodeStringToString(LinkName, &linkPrefix);
|
||
RtlAppendUnicodeStringToString(LinkName, &linkSuffix);
|
||
RtlAppendUnicodeStringToString(LinkName, &linkDigits);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
VOID
|
||
ParReleasePortInfoToPortDevice(
|
||
IN PDEVICE_EXTENSION Extension
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine will release the port information back to the port driver.
|
||
|
||
Arguments:
|
||
|
||
Extension - Supplies the device extension.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
KEVENT event;
|
||
PIRP irp;
|
||
IO_STATUS_BLOCK ioStatus;
|
||
NTSTATUS status;
|
||
|
||
KeInitializeEvent(&event, NotificationEvent, FALSE);
|
||
|
||
irp = IoBuildDeviceIoControlRequest(IOCTL_INTERNAL_RELEASE_PARALLEL_PORT_INFO,
|
||
Extension->PortDeviceObject,
|
||
NULL, 0, NULL, 0,
|
||
TRUE, &event, &ioStatus);
|
||
|
||
if (!irp) {
|
||
return;
|
||
}
|
||
|
||
status = IoCallDriver(Extension->PortDeviceObject, irp);
|
||
|
||
if (!NT_SUCCESS(status)) {
|
||
return;
|
||
}
|
||
|
||
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
|
||
}
|
||
|
||
NTSTATUS
|
||
ParGetPortInfoFromPortDevice(
|
||
IN OUT PDEVICE_EXTENSION Extension
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine will request the port information from the port driver
|
||
and fill it in the device extension.
|
||
|
||
Arguments:
|
||
|
||
Extension - Supplies the device extension.
|
||
|
||
Return Value:
|
||
|
||
STATUS_SUCCESS - Success.
|
||
!STATUS_SUCCESS - Failure.
|
||
|
||
--*/
|
||
|
||
{
|
||
KEVENT event;
|
||
PIRP irp;
|
||
PARALLEL_PORT_INFORMATION portInfo;
|
||
IO_STATUS_BLOCK ioStatus;
|
||
NTSTATUS status;
|
||
|
||
KeInitializeEvent(&event, NotificationEvent, FALSE);
|
||
|
||
irp = IoBuildDeviceIoControlRequest(IOCTL_INTERNAL_GET_PARALLEL_PORT_INFO,
|
||
Extension->PortDeviceObject,
|
||
NULL, 0, &portInfo,
|
||
sizeof(PARALLEL_PORT_INFORMATION),
|
||
TRUE, &event, &ioStatus);
|
||
|
||
if (!irp) {
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
status = IoCallDriver(Extension->PortDeviceObject, irp);
|
||
|
||
if (!NT_SUCCESS(status)) {
|
||
return status;
|
||
}
|
||
|
||
status = KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
|
||
|
||
if (!NT_SUCCESS(status)) {
|
||
return status;
|
||
}
|
||
|
||
Extension->OriginalController = portInfo.OriginalController;
|
||
Extension->Controller = portInfo.Controller;
|
||
Extension->SpanOfController = portInfo.SpanOfController;
|
||
Extension->FreePort = portInfo.FreePort;
|
||
Extension->FreePortContext = portInfo.Context;
|
||
|
||
if (Extension->SpanOfController < PARALLEL_REGISTER_SPAN) {
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
return status;
|
||
}
|
||
|
||
VOID
|
||
ParCompleteRequest(
|
||
IN PDEVICE_EXTENSION Extension,
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine completes the 'CurrentIrp' after it was returned
|
||
from the port driver.
|
||
|
||
Arguments:
|
||
|
||
Extension - Supplies the device extension.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
// DbgPrint("ParVDMCompleteRequest: Enter with irp = %#08x\n", Irp);
|
||
//
|
||
// If the allocate failed, then fail this request
|
||
//
|
||
|
||
if (!NT_SUCCESS(Irp->IoStatus.Status)) {
|
||
DbgPrint("ParVDMCompleteRequest: Completing request with status %#08x\n",
|
||
Irp->IoStatus.Status);
|
||
|
||
// failed to allocate port, release port info back to port driver
|
||
// and paged ourselves out.
|
||
ParReleasePortInfoToPortDevice(Extension);
|
||
ParReleaseDriver();
|
||
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
||
return;
|
||
}
|
||
|
||
//
|
||
// This is where the driver specific stuff should go. The driver
|
||
// has exclusive access to the parallel port in this space.
|
||
//
|
||
|
||
// DbgPrint("ParVDMCompleteRequest: We own the port\n");
|
||
Extension->PortOwned = TRUE;
|
||
|
||
//
|
||
// Complete the IRP, free the port, and start up the next IRP in
|
||
// the queue.
|
||
//
|
||
|
||
Irp->IoStatus.Status = STATUS_SUCCESS;
|
||
Irp->IoStatus.Information = 0;
|
||
IoCompleteRequest(Irp, IO_PARALLEL_INCREMENT);
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
VOID
|
||
ParCancel(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This is the cancel routine for this driver.
|
||
|
||
Arguments:
|
||
|
||
DeviceObject - Supplies the device object.
|
||
|
||
Irp - Supplies the I/O request packet.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
|
||
IoReleaseCancelSpinLock(Irp->CancelIrql);
|
||
|
||
Irp->IoStatus.Information = 0;
|
||
Irp->IoStatus.Status = STATUS_CANCELLED;
|
||
|
||
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
||
}
|
||
|
||
NTSTATUS
|
||
ParCreateOpen(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is the dispatch for create requests.
|
||
|
||
Arguments:
|
||
|
||
DeviceObject - Supplies the device object.
|
||
|
||
Irp - Supplies the I/O request packet.
|
||
|
||
Return Value:
|
||
|
||
STATUS_SUCCESS - Success.
|
||
STATUS_NOT_A_DIRECTORY - This device is not a directory.
|
||
|
||
--*/
|
||
|
||
{
|
||
PIO_STACK_LOCATION irpSp;
|
||
NTSTATUS status;
|
||
PDEVICE_EXTENSION extension = DeviceObject->DeviceExtension;
|
||
|
||
|
||
if (extension->PortOwned)
|
||
return STATUS_ACCESS_DENIED;
|
||
|
||
irpSp = IoGetCurrentIrpStackLocation(Irp);
|
||
|
||
if (irpSp->MajorFunction == IRP_MJ_CREATE &&
|
||
irpSp->Parameters.Create.Options & FILE_DIRECTORY_FILE) {
|
||
|
||
status = STATUS_NOT_A_DIRECTORY;
|
||
} else {
|
||
status = STATUS_SUCCESS;
|
||
}
|
||
|
||
|
||
//Lock in code
|
||
ParClaimDriver();
|
||
|
||
// lock in port driver
|
||
ParGetPortInfoFromPortDevice(extension);
|
||
|
||
status = ParAllocPort(extension, Irp);
|
||
|
||
// DbgPrint("ParVDMDeviceControl: ParAllocPort returned %#08lx\n");
|
||
|
||
return status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
ParClose(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is the dispatch for a close requests.
|
||
|
||
Arguments:
|
||
|
||
DeviceObject - Supplies the device object.
|
||
|
||
Irp - Supplies the I/O request packet.
|
||
|
||
Return Value:
|
||
|
||
STATUS_SUCCESS - Success.
|
||
|
||
--*/
|
||
|
||
{
|
||
PDEVICE_EXTENSION extension;
|
||
NTSTATUS statusOfWait;
|
||
|
||
|
||
extension = DeviceObject->DeviceExtension;
|
||
|
||
if (!extension->PortOwned)
|
||
return STATUS_ACCESS_DENIED;
|
||
|
||
|
||
// free the port for other uses
|
||
extension->FreePort(extension->FreePortContext);
|
||
extension->PortOwned = FALSE;
|
||
|
||
// Allow the port driver to be paged.
|
||
ParReleasePortInfoToPortDevice(extension);
|
||
|
||
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
||
|
||
|
||
// Unlock the code that was locked during the open.
|
||
|
||
ParReleaseDriver();
|
||
|
||
// DbgPrint("ParVDMClose: Close device, we no longer own the port\n");
|
||
return STATUS_SUCCESS;
|
||
}
|
||
|
||
NTSTATUS
|
||
ParAllocateCompletionRoutine(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp,
|
||
IN PVOID Extension
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This is the completion routine for the device control request.
|
||
This driver has exclusive access to the parallel port in this
|
||
routine.
|
||
|
||
Arguments:
|
||
|
||
DeviceObject - Supplies the device object.
|
||
|
||
Irp - Supplies the I/O request packet.
|
||
|
||
Extension - Supplies the device extension.
|
||
|
||
Return Value:
|
||
|
||
STATUS_MORE_PROCESSING_REQUIRED
|
||
|
||
--*/
|
||
|
||
{
|
||
KIRQL oldIrql;
|
||
LONG irpRef;
|
||
|
||
ParCompleteRequest(Extension, Irp);
|
||
|
||
// If the IRP was completed. It was completed with 'IoCompleteRequest'.
|
||
|
||
return STATUS_MORE_PROCESSING_REQUIRED;
|
||
}
|
||
|
||
NTSTATUS
|
||
ParAllocPort(
|
||
IN PDEVICE_EXTENSION Extension,
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine takes the 'CurrentIrp' and sends it down to the
|
||
port driver as an allocate parallel port request.
|
||
|
||
Arguments:
|
||
|
||
Extension - Supplies the device extension.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
PIO_STACK_LOCATION nextSp;
|
||
// DbgPrint("ParVDMAllocPort: Entry\n");
|
||
|
||
nextSp = IoGetNextIrpStackLocation(Irp);
|
||
nextSp->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
|
||
nextSp->Parameters.DeviceIoControl.IoControlCode =
|
||
IOCTL_INTERNAL_PARALLEL_PORT_ALLOCATE;
|
||
|
||
IoSetCompletionRoutine(Irp,
|
||
ParAllocateCompletionRoutine,
|
||
Extension, TRUE, TRUE, TRUE);
|
||
|
||
// DbgPrint("ParVDMAllocPort: Sending Request and exiting\n");
|
||
return IoCallDriver(Extension->PortDeviceObject, Irp);
|
||
}
|
||
|
||
NTSTATUS
|
||
ParDeviceControl(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is the dispatch for device control requests.
|
||
|
||
Arguments:
|
||
|
||
DeviceObject - Supplies the device object.
|
||
|
||
Irp - Supplies the I/O request packet.
|
||
|
||
Return Value:
|
||
|
||
STATUS_PENDING - Request pending.
|
||
|
||
--*/
|
||
|
||
{
|
||
PDEVICE_EXTENSION extension;
|
||
PIO_STACK_LOCATION currentStack;
|
||
NTSTATUS status = STATUS_INVALID_PARAMETER;
|
||
|
||
extension = DeviceObject->DeviceExtension;
|
||
currentStack = IoGetCurrentIrpStackLocation(Irp);
|
||
|
||
switch(currentStack->Parameters.DeviceIoControl.IoControlCode) {
|
||
|
||
case IOCTL_VDM_PAR_WRITE_DATA_PORT: {
|
||
|
||
// DbgPrint("ParVDMDeviceControl: IOCTL_VDM_PAR_WRITE_DATA_PORT\n");
|
||
if(extension->PortOwned) {
|
||
UCHAR *data = (PUCHAR) Irp->AssociatedIrp.SystemBuffer;
|
||
ULONG length = currentStack->Parameters.DeviceIoControl.InputBufferLength;
|
||
|
||
Irp->IoStatus.Information = length;
|
||
|
||
if (length == 1) {
|
||
WRITE_PORT_UCHAR(extension->Controller +
|
||
PARALLEL_DATA_OFFSET,
|
||
*data);
|
||
} else {
|
||
|
||
for(; length != 0; length--, data++) {
|
||
WRITE_PORT_UCHAR(extension->Controller +
|
||
PARALLEL_DATA_OFFSET,
|
||
*data);
|
||
// KeStallExecutionProcessor(1);
|
||
}
|
||
}
|
||
|
||
status = STATUS_SUCCESS;
|
||
|
||
} else {
|
||
|
||
status = STATUS_ACCESS_DENIED;
|
||
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
case IOCTL_VDM_PAR_READ_STATUS_PORT: {
|
||
|
||
// DbgPrint("ParVDMDeviceControl: IOCTL_VDM_PAR_READ_STATUS_PORT\n");
|
||
if (extension->PortOwned) {
|
||
|
||
if(currentStack->Parameters.DeviceIoControl.OutputBufferLength >= sizeof(UCHAR)) {
|
||
|
||
*(PUCHAR)(Irp->AssociatedIrp.SystemBuffer) =
|
||
READ_PORT_UCHAR(extension->Controller +
|
||
PARALLEL_STATUS_OFFSET);
|
||
|
||
status = STATUS_SUCCESS;
|
||
Irp->IoStatus.Information = sizeof(UCHAR);
|
||
|
||
} else {
|
||
status = STATUS_INVALID_PARAMETER;
|
||
}
|
||
} else {
|
||
status = STATUS_ACCESS_DENIED;
|
||
}
|
||
break;
|
||
}
|
||
|
||
case IOCTL_VDM_PAR_WRITE_CONTROL_PORT: {
|
||
|
||
// DbgPrint("ParVDMDeviceControl: IOCTL_VDM_PAR_WRITE_CONTROL_PORT\n");
|
||
if(extension->PortOwned) {
|
||
|
||
if(currentStack->Parameters.DeviceIoControl.OutputBufferLength >= sizeof(UCHAR)) {
|
||
|
||
WRITE_PORT_UCHAR(
|
||
extension->Controller + PARALLEL_CONTROL_OFFSET,
|
||
*(PUCHAR)(Irp->AssociatedIrp.SystemBuffer)
|
||
);
|
||
|
||
status = STATUS_SUCCESS;
|
||
Irp->IoStatus.Information = sizeof(UCHAR);
|
||
} else {
|
||
status = STATUS_INVALID_PARAMETER;
|
||
}
|
||
} else {
|
||
status = STATUS_ACCESS_DENIED;
|
||
}
|
||
break;
|
||
}
|
||
|
||
default: {
|
||
DbgPrint("ParVDMDeviceControl: Unknown IOCTL\n");
|
||
status = STATUS_INVALID_PARAMETER;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// DbgPrint("ParVDMDeviceControl: Exit with status %#08lx\n", status);
|
||
|
||
IoCompleteRequest(Irp, IO_PARALLEL_INCREMENT);
|
||
return status;
|
||
}
|
||
|
||
VOID
|
||
ParUnload(
|
||
IN PDRIVER_OBJECT DriverObject
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine loops through the device list and cleans up after
|
||
each of the devices.
|
||
|
||
Arguments:
|
||
|
||
DriverObject - Supplies the driver object.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
PDEVICE_OBJECT currentDevice;
|
||
PDEVICE_EXTENSION extension;
|
||
KEVENT event;
|
||
PARALLEL_INTERRUPT_SERVICE_ROUTINE interruptService;
|
||
PIRP irp;
|
||
IO_STATUS_BLOCK ioStatus;
|
||
|
||
while (currentDevice = DriverObject->DeviceObject) {
|
||
|
||
extension = currentDevice->DeviceExtension;
|
||
|
||
if (extension->CreatedSymbolicLink) {
|
||
IoDeleteSymbolicLink(&extension->SymbolicLinkName);
|
||
ExFreePool(extension->SymbolicLinkName.Buffer);
|
||
}
|
||
|
||
IoDeleteDevice(currentDevice);
|
||
}
|
||
}
|