serenum.h File Reference

#include <ntifs.h>
#include <ntddser.h>

Include dependency graph for serenum.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_COMMON_DEVICE_EXTENSION
struct	_FDO_DEVICE_EXTENSION
struct	_PDO_DEVICE_EXTENSION

Macros
#define	SERENUM_TAG   'ereS'
#define	FLAG_ENUMERATION_DONE   0x01

Typedefs
typedef struct _COMMON_DEVICE_EXTENSION	COMMON_DEVICE_EXTENSION
typedef struct _COMMON_DEVICE_EXTENSION *	PCOMMON_DEVICE_EXTENSION
typedef struct _FDO_DEVICE_EXTENSION	FDO_DEVICE_EXTENSION
typedef struct _FDO_DEVICE_EXTENSION *	PFDO_DEVICE_EXTENSION
typedef struct _PDO_DEVICE_EXTENSION	PDO_DEVICE_EXTENSION
typedef struct _PDO_DEVICE_EXTENSION *	PPDO_DEVICE_EXTENSION

Enumerations
enum	SERENUM_DEVICE_STATE {   dsStopped , dsStarted , dsPaused , dsRemoved ,   dsSurpriseRemoved }

Functions
NTSTATUS	SerenumDetectPnpDevice (IN PDEVICE_OBJECT DeviceObject, IN PDEVICE_OBJECT LowerDevice)
NTSTATUS	SerenumDetectLegacyDevice (IN PDEVICE_OBJECT DeviceObject, IN PDEVICE_OBJECT LowerDevice)
NTSTATUS	SerenumFdoPnp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	SerenumInitMultiSzString (OUT PUNICODE_STRING Destination,...)
NTSTATUS	ForwardIrpAndWait (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	ForwardIrpToLowerDeviceAndForget (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	ForwardIrpToAttachedFdoAndForget (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	ForwardIrpAndForget (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	DuplicateUnicodeString (IN ULONG Flags, IN PCUNICODE_STRING SourceString, OUT PUNICODE_STRING DestinationString)
NTSTATUS	SerenumPdoPnp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	DriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegPath)

Variables
DRIVER_ADD_DEVICE	SerenumAddDevice

Macro Definition Documentation

FLAG_ENUMERATION_DONE

#define FLAG_ENUMERATION_DONE   0x01

Definition at line 61 of file serenum.h.

SERENUM_TAG

#define SERENUM_TAG   'ereS'

Definition at line 58 of file serenum.h.

Typedef Documentation

COMMON_DEVICE_EXTENSION

typedef struct _COMMON_DEVICE_EXTENSION COMMON_DEVICE_EXTENSION

FDO_DEVICE_EXTENSION

typedef struct _FDO_DEVICE_EXTENSION FDO_DEVICE_EXTENSION

PCOMMON_DEVICE_EXTENSION

typedef struct _COMMON_DEVICE_EXTENSION * PCOMMON_DEVICE_EXTENSION

PDO_DEVICE_EXTENSION

typedef struct _PDO_DEVICE_EXTENSION PDO_DEVICE_EXTENSION

PFDO_DEVICE_EXTENSION

typedef struct _FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION

PPDO_DEVICE_EXTENSION

typedef struct _PDO_DEVICE_EXTENSION * PPDO_DEVICE_EXTENSION

Enumeration Type Documentation

SERENUM_DEVICE_STATE

enum SERENUM_DEVICE_STATE

Enumerator
dsStopped
dsStarted
dsPaused
dsRemoved
dsSurpriseRemoved

Definition at line 16 of file serenum.h.

{
  dsStopped,
  dsStarted,
  dsPaused,
  dsRemoved,
  dsSurpriseRemoved
} SERENUM_DEVICE_STATE;

Function Documentation

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	IN PDRIVER_OBJECT	DriverObject,
		IN PUNICODE_STRING	RegPath
	)

Definition at line 367 of file beep.c.

{
    PDEVICE_EXTENSION DeviceExtension;
    PDEVICE_OBJECT DeviceObject;
    UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\Device\\Beep");
    NTSTATUS Status;
 
    UNREFERENCED_PARAMETER(RegistryPath);
 
    /* Create the device */
    Status = IoCreateDevice(DriverObject,
                            sizeof(DEVICE_EXTENSION),
                            &DeviceName,
                            FILE_DEVICE_BEEP,
                            0,
                            FALSE,
                            &DeviceObject);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Make it use buffered I/O */
    DeviceObject->Flags |= DO_BUFFERED_IO;
 
    /* Setup the Driver Object */
    DriverObject->MajorFunction[IRP_MJ_CREATE] = BeepCreate;
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = BeepClose;
    DriverObject->MajorFunction[IRP_MJ_CLEANUP] = BeepCleanup;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = BeepDeviceControl;
    DriverObject->DriverUnload = BeepUnload;
    DriverObject->DriverStartIo = BeepStartIo;
 
    /* Set up device extension */
    DeviceExtension = DeviceObject->DeviceExtension;
    DeviceExtension->ReferenceCount = 0;
    DeviceExtension->TimerActive = FALSE;
    IoInitializeDpcRequest(DeviceObject, (PIO_DPC_ROUTINE)BeepDPC);
    KeInitializeTimer(&DeviceExtension->Timer);
    ExInitializeFastMutex(&DeviceExtension->Mutex);
 
    /* Page the entire driver */
    MmPageEntireDriver(DriverEntry);
    return STATUS_SUCCESS;
}

DuplicateUnicodeString()

NTSTATUS DuplicateUnicodeString	(	IN ULONG	Flags,
		IN PCUNICODE_STRING	SourceString,
		OUT PUNICODE_STRING	DestinationString
	)

Definition at line 31 of file misc.c.

{
    if (SourceString == NULL || DestinationString == NULL
     || SourceString->Length > SourceString->MaximumLength
     || (SourceString->Length == 0 && SourceString->MaximumLength > 0 && SourceString->Buffer == NULL)
     || Flags == RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING || Flags >= 4)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
 
    if ((SourceString->Length == 0)
     && (Flags != (RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE |
                   RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING)))
    {
        DestinationString->Length = 0;
        DestinationString->MaximumLength = 0;
        DestinationString->Buffer = NULL;
    }
    else
    {
        USHORT DestMaxLength = SourceString->Length;
 
        if (Flags & RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE)
            DestMaxLength += sizeof(UNICODE_NULL);
 
        DestinationString->Buffer = ExAllocatePoolWithTag(PagedPool, DestMaxLength, I8042PRT_TAG);
        if (DestinationString->Buffer == NULL)
            return STATUS_NO_MEMORY;
 
        RtlCopyMemory(DestinationString->Buffer, SourceString->Buffer, SourceString->Length);
        DestinationString->Length = SourceString->Length;
        DestinationString->MaximumLength = DestMaxLength;
 
        if (Flags & RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE)
            DestinationString->Buffer[DestinationString->Length / sizeof(WCHAR)] = 0;
    }
 
    return STATUS_SUCCESS;
}

ForwardIrpAndForget()

NTSTATUS NTAPI ForwardIrpAndForget	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 18 of file misc.c.

{
    PDEVICE_OBJECT LowerDevice = ((PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->LowerDevice;
 
    ASSERT(LowerDevice);
 
    IoSkipCurrentIrpStackLocation(Irp);
    return IoCallDriver(LowerDevice, Irp);
}

ForwardIrpAndWait()

NTSTATUS ForwardIrpAndWait	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

ForwardIrpToAttachedFdoAndForget()

NTSTATUS NTAPI ForwardIrpToAttachedFdoAndForget	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 108 of file misc.c.

{
    PPDO_DEVICE_EXTENSION DeviceExtension;
    PDEVICE_OBJECT Fdo;
 
    DeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(!DeviceExtension->Common.IsFDO);
 
    Fdo = DeviceExtension->AttachedFdo;
    ASSERT(Fdo);
    TRACE_(SERENUM, "Calling attached Fdo 0x%p\n", Fdo);
    IoSkipCurrentIrpStackLocation(Irp);
    return IoCallDriver(Fdo, Irp);
}

Referenced by IrpStub(), and SerenumPdoPnp().

ForwardIrpToLowerDeviceAndForget()

NTSTATUS NTAPI ForwardIrpToLowerDeviceAndForget	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 90 of file misc.c.

{
    PFDO_DEVICE_EXTENSION DeviceExtension;
    PDEVICE_OBJECT LowerDevice;
 
    DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(DeviceExtension->Common.IsFDO);
 
    LowerDevice = DeviceExtension->LowerDevice;
    ASSERT(LowerDevice);
    TRACE_(SERENUM, "Calling lower device 0x%p\n", LowerDevice);
    IoSkipCurrentIrpStackLocation(Irp);
    return IoCallDriver(LowerDevice, Irp);
}

Referenced by IrpStub().

SerenumDetectLegacyDevice()

NTSTATUS SerenumDetectLegacyDevice	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PDEVICE_OBJECT	LowerDevice
	)

Definition at line 444 of file detect.c.

{
    HANDLE Handle = NULL;
    ULONG Fcr, Mcr;
    ULONG BaudRate;
    ULONG Command;
    SERIAL_TIMEOUTS Timeouts;
    SERIAL_LINE_CONTROL LCR;
    ULONG i, Count = 0;
    UCHAR Buffer[16];
    UNICODE_STRING DeviceDescription;
    UNICODE_STRING DeviceId;
    UNICODE_STRING InstanceId;
    UNICODE_STRING HardwareIds;
    UNICODE_STRING CompatibleIds;
    NTSTATUS Status;
 
    TRACE_(SERENUM, "SerenumDetectLegacyDevice(DeviceObject %p, LowerDevice %p)\n",
        DeviceObject,
        LowerDevice);
 
    RtlZeroMemory(Buffer, sizeof(Buffer));
 
    /* Open port */
    Status = ObOpenObjectByPointer(
        LowerDevice,
        OBJ_KERNEL_HANDLE,
        NULL,
        0,
        NULL,
        KernelMode,
        &Handle);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Reset UART */
    TRACE_(SERENUM, "Reset UART\n");
    Mcr = 0; /* MCR: DTR/RTS/OUT2 off */
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_MODEM_CONTROL,
        &Mcr, sizeof(Mcr), NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
 
    /* Set communications parameters */
    TRACE_(SERENUM, "Set communications parameters\n");
    /* DLAB off */
    Fcr = 0;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_FIFO_CONTROL,
        &Fcr, sizeof(Fcr), NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    /* Set serial port speed */
    BaudRate = 1200;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_BAUD_RATE,
        &BaudRate, sizeof(BaudRate), NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    /* Set LCR */
    LCR.WordLength = 7;
    LCR.Parity = NO_PARITY;
    LCR.StopBits = STOP_BITS_2;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_LINE_CONTROL,
        &LCR, sizeof(LCR), NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
 
    /* Flush receive buffer */
    TRACE_(SERENUM, "Flush receive buffer\n");
    Command = SERIAL_PURGE_RXCLEAR;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_MODEM_CONTROL,
        &Command, sizeof(Command), NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    /* Wait 100 ms */
    Wait(100);
 
    /* Enable DTR/RTS */
    TRACE_(SERENUM, "Enable DTR/RTS\n");
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_DTR,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_RTS,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
 
    /* Set timeout to 500 microseconds */
    TRACE_(SERENUM, "Set timeout to 500 microseconds\n");
    Timeouts.ReadIntervalTimeout = 100;
    Timeouts.ReadTotalTimeoutMultiplier = 0;
    Timeouts.ReadTotalTimeoutConstant = 500;
    Timeouts.WriteTotalTimeoutMultiplier = Timeouts.WriteTotalTimeoutConstant = 0;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_TIMEOUTS,
        &Timeouts, sizeof(Timeouts), NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
 
    /* Fill the read buffer */
    TRACE_(SERENUM, "Fill the read buffer\n");
    Status = ReadBytes(LowerDevice, Buffer, sizeof(Buffer)/sizeof(Buffer[0]), (PVOID)&Count);
    if (!NT_SUCCESS(Status)) goto ByeBye;
 
    RtlInitUnicodeString(&DeviceId, L"Serenum\\Mouse");
    RtlInitUnicodeString(&InstanceId, L"0000"); /* FIXME */
    for (i = 0; i < Count; i++)
    {
        if (Buffer[i] == 'B')
        {
            /* Sign for Microsoft Ballpoint */
            /* Hardware id: *PNP0F09
             * Compatible id: *PNP0F0F, SERIAL_MOUSE
             */
            RtlInitUnicodeString(&DeviceDescription, L"Microsoft Ballpoint device");
            SerenumInitMultiSzString(&HardwareIds, "*PNP0F09", NULL);
            SerenumInitMultiSzString(&CompatibleIds, "*PNP0F0F", "SERIAL_MOUSE", NULL);
            Status = ReportDetectedDevice(DeviceObject,
                &DeviceDescription, &DeviceId, &InstanceId, &HardwareIds, &CompatibleIds);
            RtlFreeUnicodeString(&HardwareIds);
            RtlFreeUnicodeString(&CompatibleIds);
            goto ByeBye;
        }
        else if (Buffer[i] == 'M')
        {
            /* Sign for Microsoft Mouse protocol followed by button specifier */
            if (i == sizeof(Buffer) - 1)
            {
                /* Overflow Error */
                Status = STATUS_DEVICE_NOT_CONNECTED;
                goto ByeBye;
            }
            switch (Buffer[i + 1])
            {
                case '3':
                    /* Hardware id: *PNP0F08
                     * Compatible id: SERIAL_MOUSE
                     */
                    RtlInitUnicodeString(&DeviceDescription, L"Microsoft Mouse with 3-buttons");
                    SerenumInitMultiSzString(&HardwareIds, "*PNP0F08", NULL);
                    SerenumInitMultiSzString(&CompatibleIds, "SERIAL_MOUSE", NULL);
                    break;
                default:
                    /* Hardware id: *PNP0F01
                     * Compatible id: SERIAL_MOUSE
                     */
                    RtlInitUnicodeString(&DeviceDescription, L"Microsoft Mouse with 2-buttons or Microsoft Wheel Mouse");
                    SerenumInitMultiSzString(&HardwareIds, "*PNP0F01", NULL);
                    SerenumInitMultiSzString(&CompatibleIds, "SERIAL_MOUSE", NULL);
                    break;
            }
            Status = ReportDetectedDevice(DeviceObject,
                &DeviceDescription, &DeviceId, &InstanceId, &HardwareIds, &CompatibleIds);
            RtlFreeUnicodeString(&HardwareIds);
            RtlFreeUnicodeString(&CompatibleIds);
            goto ByeBye;
        }
    }
 
    Status = STATUS_DEVICE_NOT_CONNECTED;
 
ByeBye:
    /* Close port */
    if (Handle)
        ZwClose(Handle);
    return Status;
}

Referenced by SerenumFdoQueryBusRelations().

SerenumDetectPnpDevice()

NTSTATUS SerenumDetectPnpDevice	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PDEVICE_OBJECT	LowerDevice
	)

Definition at line 223 of file detect.c.

{
    HANDLE Handle = NULL;
    UCHAR Buffer[256];
    ULONG BaudRate;
    ULONG_PTR TotalBytesReceived = 0;
    ULONG_PTR Size;
    ULONG Msr, Purge;
    ULONG i;
    BOOLEAN BufferContainsBeginId = FALSE;
    BOOLEAN BufferContainsEndId = FALSE;
    SERIAL_LINE_CONTROL Lcr;
    SERIAL_TIMEOUTS Timeouts;
    SERIALPERF_STATS PerfStats;
    NTSTATUS Status;
 
    /* Open port */
    Status = ObOpenObjectByPointer(
        LowerDevice,
        OBJ_KERNEL_HANDLE,
        NULL,
        0,
        NULL,
        KernelMode,
        &Handle);
    if (!NT_SUCCESS(Status)) goto ByeBye;
 
    /* 1. COM port initialization, check for device enumerate */
    TRACE_(SERENUM, "COM port initialization, check for device enumerate\n");
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_CLR_DTR,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_CLR_RTS,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Wait(200);
    Size = sizeof(Msr);
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_GET_MODEMSTATUS,
        NULL, 0, &Msr, &Size);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    if ((Msr & SERIAL_DSR_STATE) == 0) goto DisconnectIdle;
 
    /* 2. COM port setup, 1st phase */
    TRACE_(SERENUM, "COM port setup, 1st phase\n");
    BaudRate = 1200;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_BAUD_RATE,
        &BaudRate, sizeof(BaudRate), NULL, 0);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Lcr.WordLength = 7;
    Lcr.Parity = NO_PARITY;
    Lcr.StopBits = STOP_BIT_1;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_LINE_CONTROL,
        &Lcr, sizeof(Lcr), NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_CLR_DTR,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_CLR_RTS,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Wait(200);
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_DTR,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Wait(200);
 
    /* 3. Wait for response, 1st phase */
    TRACE_(SERENUM, "Wait for response, 1st phase\n");
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_RTS,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Timeouts.ReadIntervalTimeout = 0;
    Timeouts.ReadTotalTimeoutMultiplier = 0;
    Timeouts.ReadTotalTimeoutConstant = 200;
    Timeouts.WriteTotalTimeoutMultiplier = Timeouts.WriteTotalTimeoutConstant = 0;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_TIMEOUTS,
        &Timeouts, sizeof(Timeouts), NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Status = ReadBytes(LowerDevice, Buffer, sizeof(Buffer), &Size);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    if (Size != 0) goto CollectPnpComDeviceId;
 
    /* 4. COM port setup, 2nd phase */
    TRACE_(SERENUM, "COM port setup, 2nd phase\n");
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_CLR_DTR,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_CLR_RTS,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Purge = SERIAL_PURGE_RXABORT | SERIAL_PURGE_RXCLEAR;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_PURGE,
        &Purge, sizeof(ULONG), NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Wait(200);
 
    /* 5. Wait for response, 2nd phase */
    TRACE_(SERENUM, "Wait for response, 2nd phase\n");
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_DTR,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_RTS,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Status = ReadBytes(LowerDevice, Buffer, 1, &TotalBytesReceived);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    if (TotalBytesReceived != 0) goto CollectPnpComDeviceId;
    Size = sizeof(Msr);
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_GET_MODEMSTATUS,
        NULL, 0, &Msr, &Size);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    if ((Msr & SERIAL_DSR_STATE) == 0) goto VerifyDisconnect; else goto ConnectIdle;
 
    /* 6. Collect PnP COM device ID */
CollectPnpComDeviceId:
    TRACE_(SERENUM, "Collect PnP COM device ID\n");
    Timeouts.ReadIntervalTimeout = 200;
    Timeouts.ReadTotalTimeoutMultiplier = 0;
    Timeouts.ReadTotalTimeoutConstant = 2200;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_TIMEOUTS,
        &Timeouts, sizeof(Timeouts), NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Status = ReadBytes(LowerDevice, &Buffer[TotalBytesReceived], sizeof(Buffer) - TotalBytesReceived, &Size);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    TotalBytesReceived += Size;
    Size = sizeof(PerfStats);
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_GET_STATS,
        NULL, 0, &PerfStats, &Size);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    if (PerfStats.FrameErrorCount + PerfStats.ParityErrorCount != 0) goto ConnectIdle;
    for (i = 0; i < TotalBytesReceived; i++)
    {
        if (Buffer[i] == BEGIN_ID) BufferContainsBeginId = TRUE;
        if (Buffer[i] == END_ID) BufferContainsEndId = TRUE;
    }
    if (TotalBytesReceived == 1 || BufferContainsEndId)
    {
        if (IsValidPnpIdString(Buffer, TotalBytesReceived))
        {
            Status = ReportDetectedPnpDevice(Buffer, TotalBytesReceived);
            goto ByeBye;
        }
        goto ConnectIdle;
    }
    if (!BufferContainsBeginId) goto ConnectIdle;
    if (!BufferContainsEndId) goto ConnectIdle;
    Size = sizeof(Msr);
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_GET_MODEMSTATUS,
        NULL, 0, &Msr, &Size);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    if ((Msr & SERIAL_DSR_STATE) == 0) goto VerifyDisconnect;
 
    /* 7. Verify disconnect */
VerifyDisconnect:
    TRACE_(SERENUM, "Verify disconnect\n");
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_DTR,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_CLR_RTS,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Wait(5000);
    goto DisconnectIdle;
 
    /* 8. Connect idle */
ConnectIdle:
    TRACE_(SERENUM, "Connect idle\n");
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_DTR,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_CLR_RTS,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    BaudRate = 300;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_BAUD_RATE,
        &BaudRate, sizeof(BaudRate), NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Lcr.WordLength = 7;
    Lcr.Parity = NO_PARITY;
    Lcr.StopBits = STOP_BIT_1;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_LINE_CONTROL,
        &Lcr, sizeof(Lcr), NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    if (TotalBytesReceived == 0)
        Status = STATUS_DEVICE_NOT_CONNECTED;
    else
        Status = STATUS_SUCCESS;
    goto ByeBye;
 
    /* 9. Disconnect idle */
DisconnectIdle:
    TRACE_(SERENUM, "Disconnect idle\n");
    /* FIXME: report to OS device removal, if it was present */
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_DTR,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_CLR_RTS,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    BaudRate = 300;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_BAUD_RATE,
        &BaudRate, sizeof(BaudRate), NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Lcr.WordLength = 7;
    Lcr.Parity = NO_PARITY;
    Lcr.StopBits = STOP_BIT_1;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_LINE_CONTROL,
        &Lcr, sizeof(Lcr), NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Status = STATUS_DEVICE_NOT_CONNECTED;
 
ByeBye:
    /* Close port */
    if (Handle)
        ZwClose(Handle);
    return Status;
}

Referenced by SerenumFdoQueryBusRelations().

SerenumFdoPnp()

NTSTATUS SerenumFdoPnp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 152 of file fdo.c.

{
    PFDO_DEVICE_EXTENSION FdoExtension;
    ULONG MinorFunction;
    PIO_STACK_LOCATION Stack;
    ULONG_PTR Information = 0;
    NTSTATUS Status;
 
    Stack = IoGetCurrentIrpStackLocation(Irp);
    MinorFunction = Stack->MinorFunction;
 
    switch (MinorFunction)
    {
        /* FIXME: do all these minor functions
        IRP_MN_QUERY_REMOVE_DEVICE 0x1
        IRP_MN_REMOVE_DEVICE 0x2
        IRP_MN_CANCEL_REMOVE_DEVICE 0x3
        IRP_MN_STOP_DEVICE 0x4
        IRP_MN_QUERY_STOP_DEVICE 0x5
        IRP_MN_CANCEL_STOP_DEVICE 0x6
        IRP_MN_QUERY_DEVICE_RELATIONS / RemovalRelations (optional) 0x7
        IRP_MN_QUERY_INTERFACE (optional) 0x8
        IRP_MN_QUERY_CAPABILITIES (optional) 0x9
        IRP_MN_QUERY_PNP_DEVICE_STATE (optional) 0x14
        IRP_MN_DEVICE_USAGE_NOTIFICATION (required or optional) 0x16
        IRP_MN_SURPRISE_REMOVAL 0x17
        */
        case IRP_MN_START_DEVICE: /* 0x0 */
        {
            TRACE_(SERENUM, "IRP_MJ_PNP / IRP_MN_START_DEVICE\n");
            /* Call lower driver */
            FdoExtension = DeviceObject->DeviceExtension;
            Status = STATUS_UNSUCCESSFUL;
 
            if (IoForwardIrpSynchronously(FdoExtension->LowerDevice, Irp))
            {
                Status = Irp->IoStatus.Status;
                if (NT_SUCCESS(Status))
                {
                    Status = SerenumFdoStartDevice(DeviceObject, Irp);
                }
            }
                
            break;
        }
        case IRP_MN_QUERY_DEVICE_RELATIONS: /* 0x7 */
        {
            switch (Stack->Parameters.QueryDeviceRelations.Type)
            {
                case BusRelations:
                {
                    PDEVICE_RELATIONS DeviceRelations = NULL;
                    TRACE_(SERENUM, "IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / BusRelations\n");
                    Status = SerenumFdoQueryBusRelations(DeviceObject, &DeviceRelations);
                    Information = (ULONG_PTR)DeviceRelations;
                    break;
                }
                default:
                    TRACE_(SERENUM, "IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / Unknown type 0x%lx\n",
                        Stack->Parameters.QueryDeviceRelations.Type);
                    return ForwardIrpAndForget(DeviceObject, Irp);
            }
            break;
        }
        case IRP_MN_FILTER_RESOURCE_REQUIREMENTS: /* 0xd */
        {
            TRACE_(SERENUM, "IRP_MJ_PNP / IRP_MN_FILTER_RESOURCE_REQUIREMENTS\n");
            return ForwardIrpAndForget(DeviceObject, Irp);
        }
        default:
        {
            TRACE_(SERENUM, "IRP_MJ_PNP / unknown minor function 0x%lx\n", MinorFunction);
            return ForwardIrpAndForget(DeviceObject, Irp);
        }
    }
 
    Irp->IoStatus.Information = Information;
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return Status;
}

Referenced by SerenumPnp().

SerenumInitMultiSzString()

NTSTATUS SerenumInitMultiSzString	(	OUT PUNICODE_STRING	Destination,
			...
	)

Definition at line 18 of file misc.c.

{
    va_list args;
    PCSZ Source;
    ANSI_STRING AnsiString;
    UNICODE_STRING UnicodeString;
    ULONG DestinationSize = 0;
    NTSTATUS Status = STATUS_SUCCESS;
 
    ASSERT(Destination);
 
    /* Calculate length needed for destination unicode string */
    va_start(args, Destination);
    Source = va_arg(args, PCSZ);
    while (Source != NULL)
    {
        RtlInitAnsiString(&AnsiString, Source);
        DestinationSize += RtlAnsiStringToUnicodeSize(&AnsiString)
            + sizeof(WCHAR) /* final NULL */;
        Source = va_arg(args, PCSZ);
    }
    va_end(args);
    if (DestinationSize == 0)
    {
        RtlInitUnicodeString(Destination, NULL);
        return STATUS_SUCCESS;
    }
 
    /* Initialize destination string */
    DestinationSize += sizeof(WCHAR); // final NULL
    Destination->Buffer = (PWSTR)ExAllocatePoolWithTag(PagedPool, DestinationSize, SERENUM_TAG);
    if (!Destination->Buffer)
        return STATUS_INSUFFICIENT_RESOURCES;
    Destination->Length = 0;
    Destination->MaximumLength = (USHORT)DestinationSize;
 
    /* Copy arguments to destination string */
    /* Use a temporary unicode string, which buffer is shared with
     * destination string, to copy arguments */
    UnicodeString.Length = Destination->Length;
    UnicodeString.MaximumLength = Destination->MaximumLength;
    UnicodeString.Buffer = Destination->Buffer;
    va_start(args, Destination);
    Source = va_arg(args, PCSZ);
    while (Source != NULL)
    {
        RtlInitAnsiString(&AnsiString, Source);
        Status = RtlAnsiStringToUnicodeString(&UnicodeString, &AnsiString, FALSE);
        if (!NT_SUCCESS(Status))
        {
            ExFreePoolWithTag(Destination->Buffer, SERENUM_TAG);
            break;
        }
        Destination->Length += UnicodeString.Length + sizeof(WCHAR);
        UnicodeString.MaximumLength -= UnicodeString.Length + sizeof(WCHAR);
        UnicodeString.Buffer += UnicodeString.Length / sizeof(WCHAR) + 1;
        UnicodeString.Length = 0;
        Source = va_arg(args, PCSZ);
    }
    va_end(args);
    if (NT_SUCCESS(Status))
    {
        /* Finish multi-sz string */
        Destination->Buffer[Destination->Length / sizeof(WCHAR)] = L'\0';
        Destination->Length += sizeof(WCHAR);
    }
    return Status;
}

Referenced by SerenumDetectLegacyDevice().

SerenumPdoPnp()

NTSTATUS SerenumPdoPnp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 109 of file pdo.c.

{
    ULONG MinorFunction;
    PIO_STACK_LOCATION Stack;
    ULONG_PTR Information = 0;
    NTSTATUS Status;
 
    Stack = IoGetCurrentIrpStackLocation(Irp);
    MinorFunction = Stack->MinorFunction;
 
    switch (MinorFunction)
    {
        /* FIXME: do all these minor functions
        IRP_MN_QUERY_REMOVE_DEVICE 0x1
        IRP_MN_REMOVE_DEVICE 0x2
        IRP_MN_CANCEL_REMOVE_DEVICE 0x3
        IRP_MN_STOP_DEVICE 0x4
        IRP_MN_QUERY_STOP_DEVICE 0x5
        IRP_MN_CANCEL_STOP_DEVICE 0x6
        IRP_MN_QUERY_DEVICE_RELATIONS / EjectionRelations (optional) 0x7
        IRP_MN_QUERY_INTERFACE (required or optional) 0x8
        IRP_MN_READ_CONFIG (required or optional) 0xf
        IRP_MN_WRITE_CONFIG (required or optional) 0x10
        IRP_MN_EJECT (required or optional) 0x11
        IRP_MN_SET_LOCK (required or optional) 0x12
        IRP_MN_QUERY_ID / BusQueryDeviceID 0x13
        IRP_MN_QUERY_ID / BusQueryCompatibleIDs (optional) 0x13
        IRP_MN_QUERY_ID / BusQueryInstanceID (optional) 0x13
        IRP_MN_QUERY_PNP_DEVICE_STATE (optional) 0x14
        IRP_MN_DEVICE_USAGE_NOTIFICATION (required or optional) 0x16
        IRP_MN_SURPRISE_REMOVAL 0x17
        */
        case IRP_MN_START_DEVICE: /* 0x0 */
        {
            TRACE_(SERENUM, "IRP_MJ_PNP / IRP_MN_START_DEVICE\n");
            Status = SerenumPdoStartDevice(DeviceObject);
            break;
        }
        case IRP_MN_QUERY_DEVICE_RELATIONS: /* 0x7 */
        {
            switch (Stack->Parameters.QueryDeviceRelations.Type)
            {
                case RemovalRelations:
                {
                    return ForwardIrpToAttachedFdoAndForget(DeviceObject, Irp);
                }
                case TargetDeviceRelation:
                {
                    PDEVICE_RELATIONS DeviceRelations = NULL;
                    TRACE_(SERENUM, "IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / TargetDeviceRelation\n");
                    Status = SerenumPdoQueryDeviceRelations(DeviceObject, &DeviceRelations);
                    Information = (ULONG_PTR)DeviceRelations;
                    break;
                }
                default:
                {
                    WARN_(SERENUM, "IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / Unknown type 0x%lx\n",
                        Stack->Parameters.QueryDeviceRelations.Type);
                    ASSERT(FALSE);
                    Status = STATUS_NOT_IMPLEMENTED;
                    break;
                }
            }
            break;
        }
        case IRP_MN_QUERY_CAPABILITIES: /* 0x9 */
        {
            PDEVICE_CAPABILITIES DeviceCapabilities;
            ULONG i;
            TRACE_(SERENUM, "IRP_MJ_PNP / IRP_MN_QUERY_CAPABILITIES\n");
 
            DeviceCapabilities = (PDEVICE_CAPABILITIES)Stack->Parameters.DeviceCapabilities.Capabilities;
            /* FIXME: capabilities can change with connected device */
            DeviceCapabilities->LockSupported = FALSE;
            DeviceCapabilities->EjectSupported = FALSE;
            DeviceCapabilities->Removable = TRUE;
            DeviceCapabilities->DockDevice = FALSE;
            DeviceCapabilities->UniqueID = FALSE;
            DeviceCapabilities->SilentInstall = FALSE;
            DeviceCapabilities->RawDeviceOK = TRUE;
            DeviceCapabilities->SurpriseRemovalOK = TRUE;
            DeviceCapabilities->HardwareDisabled = FALSE; /* FIXME */
            //DeviceCapabilities->NoDisplayInUI = FALSE; /* FIXME */
            DeviceCapabilities->DeviceState[0] = PowerDeviceD0; /* FIXME */
            for (i = 0; i < PowerSystemMaximum; i++)
                DeviceCapabilities->DeviceState[i] = PowerDeviceD3; /* FIXME */
            //DeviceCapabilities->DeviceWake = PowerDeviceUndefined; /* FIXME */
            DeviceCapabilities->D1Latency = 0; /* FIXME */
            DeviceCapabilities->D2Latency = 0; /* FIXME */
            DeviceCapabilities->D3Latency = 0; /* FIXME */
            Status = STATUS_SUCCESS;
            break;
        }
        case IRP_MN_QUERY_RESOURCES: /* 0xa */
        {
            TRACE_(SERENUM, "IRP_MJ_PNP / IRP_MN_QUERY_RESOURCES\n");
            /* Serial devices don't need resources, except the ones of
             * the serial port. This PDO is the serial device PDO, so
             * report no resource by not changing Information and
             * Status
             */
            Information = Irp->IoStatus.Information;
            Status = Irp->IoStatus.Status;
            break;
        }
        case IRP_MN_QUERY_RESOURCE_REQUIREMENTS: /* 0xb */
        {
            TRACE_(SERENUM, "IRP_MJ_PNP / IRP_MN_QUERY_RESOURCE_REQUIREMENTS\n");
            /* Serial devices don't need resources, except the ones of
             * the serial port. This PDO is the serial device PDO, so
             * report no resource by not changing Information and
             * Status
             */
            Information = Irp->IoStatus.Information;
            Status = Irp->IoStatus.Status;
            break;
        }
        case IRP_MN_QUERY_DEVICE_TEXT: /* 0xc */
        {
            switch (Stack->Parameters.QueryDeviceText.DeviceTextType)
            {
                case DeviceTextDescription:
                {
                    PUNICODE_STRING Source;
                    PWSTR Description;
                    TRACE_(SERENUM, "IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_TEXT / DeviceTextDescription\n");
 
                    Source = &((PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->DeviceDescription;
                    Description = ExAllocatePoolWithTag(PagedPool, Source->Length + sizeof(WCHAR), SERENUM_TAG);
                    if (!Description)
                        Status = STATUS_INSUFFICIENT_RESOURCES;
                    else
                    {
                        RtlCopyMemory(Description, Source->Buffer, Source->Length);
                        Description[Source->Length / sizeof(WCHAR)] = L'\0';
                        Information = (ULONG_PTR)Description;
                        Status = STATUS_SUCCESS;
                    }
                    break;
                }
                case DeviceTextLocationInformation:
                {
                    /* We don't have any text location to report,
                     * and this query is optional, so ignore it.
                     */
                    Information = Irp->IoStatus.Information;
                    Status = Irp->IoStatus.Status;
                    break;
                }
                default:
                {
                    WARN_(SERENUM, "IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_TEXT / unknown type 0x%lx\n",
                        Stack->Parameters.QueryDeviceText.DeviceTextType);
                    ASSERT(FALSE);
                    Status = STATUS_NOT_SUPPORTED;
                }
            }
            break;
        }
        case IRP_MN_FILTER_RESOURCE_REQUIREMENTS: /* 0xd */
        {
            return ForwardIrpToAttachedFdoAndForget(DeviceObject, Irp);
        }
        case IRP_MN_QUERY_ID: /* 0x13 */
        {
            Status = SerenumPdoQueryId(DeviceObject, Irp, &Information);
            break;
        }
        case IRP_MN_QUERY_BUS_INFORMATION: /* 0x15 */
        {
            PPNP_BUS_INFORMATION BusInfo;
            TRACE_(SERENUM, "IRP_MJ_PNP / IRP_MN_QUERY_BUS_INFORMATION\n");
 
            BusInfo = (PPNP_BUS_INFORMATION)ExAllocatePoolWithTag(PagedPool, sizeof(PNP_BUS_INFORMATION), SERENUM_TAG);
            if (!BusInfo)
                Status = STATUS_INSUFFICIENT_RESOURCES;
            else
            {
                memcpy(
                    &BusInfo->BusTypeGuid,
                    &GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR,
                    sizeof(BusInfo->BusTypeGuid));
                BusInfo->LegacyBusType = PNPBus;
                /* We're the only serial bus enumerator on the computer */
                BusInfo->BusNumber = 0;
                Information = (ULONG_PTR)BusInfo;
                Status = STATUS_SUCCESS;
            }
            break;
        }
        default:
        {
            /* We can't forward request to the lower driver, because
             * we are a Pdo, so we don't have lower driver... */
            WARN_(SERENUM, "IRP_MJ_PNP / unknown minor function 0x%lx\n", MinorFunction);
            ASSERT(FALSE);
            Information = Irp->IoStatus.Information;
            Status = Irp->IoStatus.Status;
        }
    }
 
    Irp->IoStatus.Information = Information;
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return Status;
}

Referenced by SerenumPnp().

Variable Documentation

SerenumAddDevice

DRIVER_ADD_DEVICE SerenumAddDevice

Definition at line 77 of file serenum.h.

Referenced by DriverEntry().