#include <ntifs.h>

Include dependency graph for fdc.h:

This graph shows which files directly or indirectly include 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

Macro Definition Documentation

◆ FDC_TAG

#define FDC_TAG 'acdF'

Definition at line 102 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 444 of file fdo.c.

{
    PFDO_DEVICE_EXTENSION FdoExtension;
    PIO_STACK_LOCATION IrpSp;
    PDEVICE_RELATIONS DeviceRelations = NULL;
    ULONG_PTR Information = 0;
    NTSTATUS Status = STATUS_NOT_SUPPORTED;
 
    DPRINT("FdcFdoPnp()\n");
 
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
    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");
            break;
 
        case IRP_MN_REMOVE_DEVICE:
            DPRINT("  IRP_MN_REMOVE_DEVICE received\n");
            break;
 
        case IRP_MN_CANCEL_REMOVE_DEVICE:
            DPRINT("  IRP_MN_CANCEL_REMOVE_DEVICE\n");
            break;
 
        case IRP_MN_STOP_DEVICE:
            DPRINT("  IRP_MN_STOP_DEVICE received\n");
            break;
 
        case IRP_MN_QUERY_STOP_DEVICE:
            DPRINT("  IRP_MN_QUERY_STOP_DEVICE received\n");
            break;
 
        case IRP_MN_CANCEL_STOP_DEVICE:
            DPRINT("  IRP_MN_CANCEL_STOP_DEVICE\n");
            break;
 
        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, &DeviceRelations);
                    Information = (ULONG_PTR)DeviceRelations;
                    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");
            break;
 
        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().

◆ FdcPdoPnp()

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

Definition at line 98 of file pdo.c.

{
    PIO_STACK_LOCATION IrpSp;
    ULONG_PTR Information = 0;
    NTSTATUS Status;
 
    DPRINT("FdcPdoPnp()\n");
 
    Status = Irp->IoStatus.Status;
 
    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");
            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");
            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:
        case IRP_MN_SURPRISE_REMOVAL:
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_REMOVE_DEVICE:
            DPRINT("IRP_MN_REMOVE_DEVICE received\n");
            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);
 
    return Status;
}