fdc.h File Reference

#include <ntifs.h>

Include dependency graph for fdc.h:

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

Go to the source code of this file.

Classes
struct	_DRIVE_INFO
struct	_CONTROLLER_INFO
struct	_COMMON_DEVICE_EXTENSION
struct	_FDO_DEVICE_EXTENSION
struct	_PDO_DEVICE_EXTENSION

Macros
#define	MAX_DEVICE_NAME   255
#define	MAX_ARC_PATH_LEN   255
#define	MAX_DRIVES_PER_CONTROLLER   4
#define	MAX_CONTROLLERS   4
#define	FDC_TAG   'acdF'

Typedefs
typedef struct _DRIVE_INFO	DRIVE_INFO
typedef struct _DRIVE_INFO *	PDRIVE_INFO
typedef struct _CONTROLLER_INFO	CONTROLLER_INFO
typedef struct _CONTROLLER_INFO *	PCONTROLLER_INFO
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

Functions
NTSTATUS NTAPI	FdcFdoPnp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	DuplicateUnicodeString (IN ULONG Flags, IN PCUNICODE_STRING SourceString, OUT PUNICODE_STRING DestinationString)
VOID	FdcPdoDeleteDevice (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI	FdcPdoPnp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)

Macro Definition Documentation

FDC_TAG

#define FDC_TAG   'acdF'

Definition at line 105 of file fdc.h.

MAX_ARC_PATH_LEN

#define MAX_ARC_PATH_LEN   255

Definition at line 15 of file fdc.h.

MAX_CONTROLLERS

#define MAX_CONTROLLERS   4

Definition at line 17 of file fdc.h.

MAX_DEVICE_NAME

#define MAX_DEVICE_NAME   255

Definition at line 14 of file fdc.h.

MAX_DRIVES_PER_CONTROLLER

#define MAX_DRIVES_PER_CONTROLLER   4

Definition at line 16 of file fdc.h.

Typedef Documentation

COMMON_DEVICE_EXTENSION

typedef struct _COMMON_DEVICE_EXTENSION COMMON_DEVICE_EXTENSION

CONTROLLER_INFO

typedef struct _CONTROLLER_INFO CONTROLLER_INFO

DRIVE_INFO

typedef struct _DRIVE_INFO DRIVE_INFO

FDO_DEVICE_EXTENSION

typedef struct _FDO_DEVICE_EXTENSION FDO_DEVICE_EXTENSION

PCOMMON_DEVICE_EXTENSION

typedef struct _COMMON_DEVICE_EXTENSION * PCOMMON_DEVICE_EXTENSION

PCONTROLLER_INFO

typedef struct _CONTROLLER_INFO * PCONTROLLER_INFO

PDO_DEVICE_EXTENSION

typedef struct _PDO_DEVICE_EXTENSION PDO_DEVICE_EXTENSION

PDRIVE_INFO

typedef struct _DRIVE_INFO * PDRIVE_INFO

PFDO_DEVICE_EXTENSION

typedef struct _FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION

PPDO_DEVICE_EXTENSION

typedef struct _PDO_DEVICE_EXTENSION * PPDO_DEVICE_EXTENSION

Function Documentation

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;
}

FdcFdoPnp()

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

Definition at line 621 of file fdo.c.

{
    PFDO_DEVICE_EXTENSION FdoExtension;
    PIO_STACK_LOCATION IrpSp;
    PDEVICE_RELATIONS DeviceRelations = NULL;
    PDEVICE_OBJECT Pdo;
    ULONG_PTR Information;
    NTSTATUS Status = STATUS_NOT_SUPPORTED;
    ULONG i;
 
    DPRINT("FdcFdoPnp()\n");
 
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
    Information = Irp->IoStatus.Information;
 
    switch (IrpSp->MinorFunction)
    {
        case IRP_MN_START_DEVICE:
            DPRINT("  IRP_MN_START_DEVICE received\n");
            
            /* Call lower driver */
            Status = STATUS_UNSUCCESSFUL;
            FdoExtension = DeviceObject->DeviceExtension;
 
            if (IoForwardIrpSynchronously(FdoExtension->LowerDevice, Irp))
            {
                Status = Irp->IoStatus.Status;
                if (NT_SUCCESS(Status))
                {
                    Status = FdcFdoStartDevice(DeviceObject,
                        IrpSp->Parameters.StartDevice.AllocatedResources,
                        IrpSp->Parameters.StartDevice.AllocatedResourcesTranslated);
                }
            }
 
            break;
 
        case IRP_MN_QUERY_REMOVE_DEVICE:
            DPRINT("  IRP_MN_QUERY_REMOVE_DEVICE\n");
            Irp->IoStatus.Status = STATUS_SUCCESS;
            return ForwardIrpAndForget(DeviceObject, Irp);
 
        case IRP_MN_REMOVE_DEVICE:
            DPRINT("  IRP_MN_REMOVE_DEVICE received\n");
            FdoExtension = DeviceObject->DeviceExtension;
 
            for (i = 0; i < FdoExtension->ControllerInfo.NumberOfDrives; i++)
            {
                Pdo = FdoExtension->ControllerInfo.DriveInfo[i].DeviceObject;
                if (Pdo != NULL)
                    FdcPdoDeleteDevice(Pdo);
            }
 
            /* The lower stack owns the remove IRP after we forward it. */
            Irp->IoStatus.Status = STATUS_SUCCESS;
            IoSkipCurrentIrpStackLocation(Irp);
            Status = IoCallDriver(FdoExtension->LowerDevice, Irp);
 
            IoDetachDevice(FdoExtension->LowerDevice);
            IoDeleteDevice(DeviceObject);
            return Status;
 
        case IRP_MN_CANCEL_REMOVE_DEVICE:
            DPRINT("  IRP_MN_CANCEL_REMOVE_DEVICE\n");
            Irp->IoStatus.Status = STATUS_SUCCESS;
            return ForwardIrpAndForget(DeviceObject, Irp);
 
        case IRP_MN_STOP_DEVICE:
            DPRINT("  IRP_MN_STOP_DEVICE received\n");
            Irp->IoStatus.Status = STATUS_SUCCESS;
            return ForwardIrpAndForget(DeviceObject, Irp);
 
        case IRP_MN_QUERY_STOP_DEVICE:
            DPRINT("  IRP_MN_QUERY_STOP_DEVICE received\n");
            Irp->IoStatus.Status = STATUS_SUCCESS;
            return ForwardIrpAndForget(DeviceObject, Irp);
 
        case IRP_MN_CANCEL_STOP_DEVICE:
            DPRINT("  IRP_MN_CANCEL_STOP_DEVICE\n");
            Irp->IoStatus.Status = STATUS_SUCCESS;
            return ForwardIrpAndForget(DeviceObject, Irp);
 
        case IRP_MN_QUERY_DEVICE_RELATIONS:
            DPRINT("  IRP_MN_QUERY_DEVICE_RELATIONS\n");
 
            switch (IrpSp->Parameters.QueryDeviceRelations.Type)
            {
                case BusRelations:
                    DPRINT("    IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / BusRelations\n");
                    Status = FdcFdoQueryBusRelations(DeviceObject,
                                                     (PDEVICE_RELATIONS)Information,
                                                     &DeviceRelations);
                    if (NT_SUCCESS(Status))
                    {
                        Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
                        Irp->IoStatus.Status = STATUS_SUCCESS;
                        return ForwardIrpAndForget(DeviceObject, Irp);
                    }
                    break;
 
                case RemovalRelations:
                    DPRINT("    IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / RemovalRelations\n");
                    return ForwardIrpAndForget(DeviceObject, Irp);
 
                default:
                    DPRINT("    IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / Unknown type 0x%lx\n",
                            IrpSp->Parameters.QueryDeviceRelations.Type);
                    return ForwardIrpAndForget(DeviceObject, Irp);
            }
            break;
 
        case IRP_MN_SURPRISE_REMOVAL:
            DPRINT("  IRP_MN_SURPRISE_REMOVAL received\n");
            Irp->IoStatus.Status = STATUS_SUCCESS;
            return ForwardIrpAndForget(DeviceObject, Irp);
 
        default:
            DPRINT("  Unknown IOCTL 0x%lx\n", IrpSp->MinorFunction);
            return ForwardIrpAndForget(DeviceObject, Irp);
    }
 
    Irp->IoStatus.Information = Information;
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return Status;
}

Referenced by FdcPnp().

FdcPdoDeleteDevice()

VOID FdcPdoDeleteDevice

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 120 of file pdo.c.

{
    PPDO_DEVICE_EXTENSION DeviceExtension;
 
    DeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    if (DeviceExtension->DeletePending)
        return;
 
    DeviceExtension->DeletePending = TRUE;
    DeviceExtension->ReportedPresent = FALSE;
 
    if (DeviceExtension->DriveInfo != NULL &&
        DeviceExtension->DriveInfo->DeviceObject == DeviceObject)
    {
        DeviceExtension->DriveInfo->DeviceObject = NULL;
    }
 
    DeviceExtension->DriveInfo = NULL;
    DeviceExtension->Fdo = NULL;
 
    RtlFreeUnicodeString(&DeviceExtension->DeviceDescription);
    RtlFreeUnicodeString(&DeviceExtension->DeviceId);
    RtlFreeUnicodeString(&DeviceExtension->InstanceId);
    RtlFreeUnicodeString(&DeviceExtension->HardwareIds);
    RtlFreeUnicodeString(&DeviceExtension->CompatibleIds);
 
    IoDeleteDevice(DeviceObject);
}

Referenced by FdcFdoPnp(), and FdcPdoPnp().

FdcPdoPnp()

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

Definition at line 153 of file pdo.c.

{
    PPDO_DEVICE_EXTENSION DeviceExtension;
    PIO_STACK_LOCATION IrpSp;
    ULONG_PTR Information;
    NTSTATUS Status;
    BOOLEAN DeleteDevice = FALSE;
 
    DPRINT("FdcPdoPnp()\n");
 
    Status = Irp->IoStatus.Status;
    Information = Irp->IoStatus.Information;
    DeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
    switch (IrpSp->MinorFunction)
    {
        case IRP_MN_DEVICE_USAGE_NOTIFICATION:
            DPRINT1("Unimplemented IRP_MN_DEVICE_USAGE_NOTIFICATION received\n");
            break;
 
        case IRP_MN_EJECT:
            DPRINT1("Unimplemented IRP_MN_EJECT received\n");
            break;
 
        case IRP_MN_QUERY_BUS_INFORMATION:
            DPRINT("IRP_MN_QUERY_BUS_INFORMATION received\n");
            break;
 
        case IRP_MN_QUERY_CAPABILITIES:
            DPRINT("IRP_MN_QUERY_CAPABILITIES received\n");
            Status = FdcPdoQueryCapabilities(DeviceObject, IrpSp);
            break;
 
        case IRP_MN_QUERY_DEVICE_RELATIONS:
            DPRINT("IRP_MN_QUERY_DEVICE_RELATIONS received\n");
            if (IrpSp->Parameters.QueryDeviceRelations.Type == TargetDeviceRelation)
                Status = FdcPdoQueryTargetDeviceRelation(DeviceObject, &Information);
            break;
 
        case IRP_MN_QUERY_DEVICE_TEXT:
            DPRINT("IRP_MN_QUERY_DEVICE_TEXT received\n");
            break;
 
        case IRP_MN_QUERY_ID:
            DPRINT("IRP_MN_QUERY_ID received\n");
            Status = FdcPdoQueryId(DeviceObject, IrpSp, &Information);
            break;
 
        case IRP_MN_QUERY_PNP_DEVICE_STATE:
            DPRINT1("Unimplemented IRP_MN_QUERY_ID received\n");
            break;
 
        case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
            DPRINT("IRP_MN_QUERY_RESOURCE_REQUIREMENTS received\n");
            break;
 
        case IRP_MN_QUERY_RESOURCES:
            DPRINT("IRP_MN_QUERY_RESOURCES received\n");
            break;
 
        case IRP_MN_SET_LOCK:
            DPRINT1("Unimplemented IRP_MN_SET_LOCK received\n");
            break;
 
        case IRP_MN_START_DEVICE:
            DPRINT("IRP_MN_START_DEVICE received\n");
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_QUERY_STOP_DEVICE:
        case IRP_MN_CANCEL_STOP_DEVICE:
        case IRP_MN_STOP_DEVICE:
        case IRP_MN_QUERY_REMOVE_DEVICE:
        case IRP_MN_CANCEL_REMOVE_DEVICE:
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_SURPRISE_REMOVAL:
            DeviceExtension->ReportedPresent = FALSE;
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_REMOVE_DEVICE:
            DPRINT("IRP_MN_REMOVE_DEVICE received\n");
            Status = STATUS_SUCCESS;
            DeleteDevice = !DeviceExtension->ReportedPresent &&
                           !DeviceExtension->DeletePending;
            break;
 
        case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
            DPRINT("IRP_MN_FILTER_RESOURCE_REQUIREMENTS received\n");
            /* Nothing to do */
            Irp->IoStatus.Status = Status;
            break;
 
        default:
            DPRINT1("Unknown IOCTL 0x%lx\n", IrpSp->MinorFunction);
            break;
    }
 
    Irp->IoStatus.Information = Information;
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    DPRINT("Leaving. Status 0x%X\n", Status);
 
    if (DeleteDevice)
        FdcPdoDeleteDevice(DeviceObject);
 
    return Status;
}

Referenced by FdcPnp().