scsi_port.h File Reference

#include "srb.h"

Include dependency graph for scsi_port.h:

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

Go to the source code of this file.

Classes
struct	_SCSI_PASS_THROUGH
struct	_SCSI_PASS_THROUGH_DIRECT
struct	_SCSI_BUS_DATA
struct	_SCSI_ADAPTER_BUS_INFO
struct	_SCSI_INQUIRY_DATA
struct	_SRB_IO_CONTROL
struct	_IO_SCSI_CAPABILITIES
struct	_SCSI_ADDRESS
struct	_DUMP_POINTERS

Macros
#define	IOCTL_SCSI_BASE   FILE_DEVICE_CONTROLLER
#define	DD_SCSI_DEVICE_NAME   "\\Device\\ScsiPort"
#define	IOCTL_SCSI_PASS_THROUGH   CTL_CODE(IOCTL_SCSI_BASE, 0x0401, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
#define	IOCTL_SCSI_MINIPORT   CTL_CODE(IOCTL_SCSI_BASE, 0x0402, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
#define	IOCTL_SCSI_GET_INQUIRY_DATA   CTL_CODE(IOCTL_SCSI_BASE, 0x0403, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define	IOCTL_SCSI_GET_CAPABILITIES   CTL_CODE(IOCTL_SCSI_BASE, 0x0404, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define	IOCTL_SCSI_PASS_THROUGH_DIRECT   CTL_CODE(IOCTL_SCSI_BASE, 0x0405, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
#define	IOCTL_SCSI_GET_ADDRESS   CTL_CODE(IOCTL_SCSI_BASE, 0x0406, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define	IOCTL_SCSI_RESCAN_BUS   CTL_CODE(IOCTL_SCSI_BASE, 0x0407, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define	IOCTL_SCSI_GET_DUMP_POINTERS   CTL_CODE(IOCTL_SCSI_BASE, 0x0408, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define	SCSI_IOCTL_DATA_OUT   0
#define	SCSI_IOCTL_DATA_IN   1
#define	SCSI_IOCTL_DATA_UNSPECIFIED   2
#define	CLASS_SPECIAL_CAUSE_NOT_REPORTABLE_HACK   0x00000020
#define	SCSIPORT_API

Typedefs
typedef struct _SCSI_PASS_THROUGH	SCSI_PASS_THROUGH
typedef struct _SCSI_PASS_THROUGH *	PSCSI_PASS_THROUGH
typedef struct _SCSI_PASS_THROUGH_DIRECT	SCSI_PASS_THROUGH_DIRECT
typedef struct _SCSI_PASS_THROUGH_DIRECT *	PSCSI_PASS_THROUGH_DIRECT
typedef struct _SCSI_BUS_DATA	SCSI_BUS_DATA
typedef struct _SCSI_BUS_DATA *	PSCSI_BUS_DATA
typedef struct _SCSI_ADAPTER_BUS_INFO	SCSI_ADAPTER_BUS_INFO
typedef struct _SCSI_ADAPTER_BUS_INFO *	PSCSI_ADAPTER_BUS_INFO
typedef struct _SCSI_INQUIRY_DATA	SCSI_INQUIRY_DATA
typedef struct _SCSI_INQUIRY_DATA *	PSCSI_INQUIRY_DATA
typedef struct _SRB_IO_CONTROL	SRB_IO_CONTROL
typedef struct _SRB_IO_CONTROL *	PSRB_IO_CONTROL
typedef struct _IO_SCSI_CAPABILITIES	IO_SCSI_CAPABILITIES
typedef struct _IO_SCSI_CAPABILITIES *	PIO_SCSI_CAPABILITIES
typedef struct _SCSI_ADDRESS	SCSI_ADDRESS
typedef struct _SCSI_ADDRESS *	PSCSI_ADDRESS
typedef struct _DUMP_POINTERS	DUMP_POINTERS
typedef struct _DUMP_POINTERS *	PDUMP_POINTERS

Functions
NTSTATUS	ScsiClassGetInquiryData (IN PDEVICE_OBJECT PortDeviceObject, IN PSCSI_ADAPTER_BUS_INFO *ConfigInfo)
NTSTATUS	ScsiClassReadDeviceInquiryData (IN PDEVICE_OBJECT DeviceObject, IN BOOLEAN DirectAccess)
NTSTATUS	ScsiClassReadDriveCapacity (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS	ScsiClassGetCapabilities (IN PDEVICE_OBJECT PortDeviceObject, OUT PIO_SCSI_CAPABILITIES *PortCapabilities)
NTSTATUS	ScsiClassGetAddress (IN PDEVICE_OBJECT ClassDeviceObject, OUT PSCSI_ADDRESS Address)
VOID	ScsiClassReleaseQueue (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS	ScsiClassRemoveDevice (IN PDEVICE_OBJECT PortDeviceObject, IN UCHAR PathId, IN UCHAR TargetId, IN UCHAR Lun)
NTSTATUS	ScsiClassClaimDevice (IN PDEVICE_OBJECT PortDeviceObject, IN PSCSI_INQUIRY_DATA LunInfo, IN BOOLEAN Release, OUT PDEVICE_OBJECT *NewPortDeviceObject OPTIONAL)
NTSTATUS	ScsiClassInternalIoControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	ScsiClassIoCompletion (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
NTSTATUS	ScsiClassSendSrbSynchronous (IN PDEVICE_OBJECT TargetDeviceObject, IN PSCSI_REQUEST_BLOCK _srb, IN PKEVENT event)
VOID	ScsiClassInitSrbBusAddr (PSCSI_REQUEST_BLOCK Srb, PVOID DeviceExtension)
NTSTATUS	DbgWaitForSingleObject_ (IN PVOID Object, IN PLARGE_INTEGER Timeout OPTIONAL)

Macro Definition Documentation

CLASS_SPECIAL_CAUSE_NOT_REPORTABLE_HACK

#define CLASS_SPECIAL_CAUSE_NOT_REPORTABLE_HACK   0x00000020

Definition at line 175 of file scsi_port.h.

DD_SCSI_DEVICE_NAME

#define DD_SCSI_DEVICE_NAME   "\\Device\\ScsiPort"

Definition at line 39 of file scsi_port.h.

IOCTL_SCSI_BASE

#define IOCTL_SCSI_BASE   FILE_DEVICE_CONTROLLER

Definition at line 37 of file scsi_port.h.

IOCTL_SCSI_GET_ADDRESS

#define IOCTL_SCSI_GET_ADDRESS   CTL_CODE(IOCTL_SCSI_BASE, 0x0406, METHOD_BUFFERED, FILE_ANY_ACCESS)

Definition at line 52 of file scsi_port.h.

IOCTL_SCSI_GET_CAPABILITIES

#define IOCTL_SCSI_GET_CAPABILITIES   CTL_CODE(IOCTL_SCSI_BASE, 0x0404, METHOD_BUFFERED, FILE_ANY_ACCESS)

Definition at line 50 of file scsi_port.h.

IOCTL_SCSI_GET_DUMP_POINTERS

#define IOCTL_SCSI_GET_DUMP_POINTERS   CTL_CODE(IOCTL_SCSI_BASE, 0x0408, METHOD_BUFFERED, FILE_ANY_ACCESS)

Definition at line 54 of file scsi_port.h.

IOCTL_SCSI_GET_INQUIRY_DATA

#define IOCTL_SCSI_GET_INQUIRY_DATA   CTL_CODE(IOCTL_SCSI_BASE, 0x0403, METHOD_BUFFERED, FILE_ANY_ACCESS)

Definition at line 49 of file scsi_port.h.

IOCTL_SCSI_MINIPORT

#define IOCTL_SCSI_MINIPORT   CTL_CODE(IOCTL_SCSI_BASE, 0x0402, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)

Definition at line 48 of file scsi_port.h.

IOCTL_SCSI_PASS_THROUGH

#define IOCTL_SCSI_PASS_THROUGH   CTL_CODE(IOCTL_SCSI_BASE, 0x0401, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)

Definition at line 47 of file scsi_port.h.

IOCTL_SCSI_PASS_THROUGH_DIRECT

#define IOCTL_SCSI_PASS_THROUGH_DIRECT   CTL_CODE(IOCTL_SCSI_BASE, 0x0405, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)

Definition at line 51 of file scsi_port.h.

IOCTL_SCSI_RESCAN_BUS

#define IOCTL_SCSI_RESCAN_BUS   CTL_CODE(IOCTL_SCSI_BASE, 0x0407, METHOD_BUFFERED, FILE_ANY_ACCESS)

Definition at line 53 of file scsi_port.h.

SCSI_IOCTL_DATA_IN

#define SCSI_IOCTL_DATA_IN   1

Definition at line 172 of file scsi_port.h.

SCSI_IOCTL_DATA_OUT

#define SCSI_IOCTL_DATA_OUT   0

Definition at line 171 of file scsi_port.h.

SCSI_IOCTL_DATA_UNSPECIFIED

#define SCSI_IOCTL_DATA_UNSPECIFIED   2

Definition at line 173 of file scsi_port.h.

SCSIPORT_API

#define SCSIPORT_API

Definition at line 177 of file scsi_port.h.

Typedef Documentation

DUMP_POINTERS

typedef struct _DUMP_POINTERS DUMP_POINTERS

IO_SCSI_CAPABILITIES

typedef struct _IO_SCSI_CAPABILITIES IO_SCSI_CAPABILITIES

PDUMP_POINTERS

typedef struct _DUMP_POINTERS * PDUMP_POINTERS

PIO_SCSI_CAPABILITIES

typedef struct _IO_SCSI_CAPABILITIES * PIO_SCSI_CAPABILITIES

PSCSI_ADAPTER_BUS_INFO

typedef struct _SCSI_ADAPTER_BUS_INFO * PSCSI_ADAPTER_BUS_INFO

PSCSI_ADDRESS

typedef struct _SCSI_ADDRESS * PSCSI_ADDRESS

PSCSI_BUS_DATA

typedef struct _SCSI_BUS_DATA * PSCSI_BUS_DATA

PSCSI_INQUIRY_DATA

typedef struct _SCSI_INQUIRY_DATA * PSCSI_INQUIRY_DATA

PSCSI_PASS_THROUGH

typedef struct _SCSI_PASS_THROUGH * PSCSI_PASS_THROUGH

PSCSI_PASS_THROUGH_DIRECT

typedef struct _SCSI_PASS_THROUGH_DIRECT * PSCSI_PASS_THROUGH_DIRECT

PSRB_IO_CONTROL

typedef struct _SRB_IO_CONTROL * PSRB_IO_CONTROL

SCSI_ADAPTER_BUS_INFO

typedef struct _SCSI_ADAPTER_BUS_INFO SCSI_ADAPTER_BUS_INFO

SCSI_ADDRESS

typedef struct _SCSI_ADDRESS SCSI_ADDRESS

SCSI_BUS_DATA

typedef struct _SCSI_BUS_DATA SCSI_BUS_DATA

SCSI_INQUIRY_DATA

typedef struct _SCSI_INQUIRY_DATA SCSI_INQUIRY_DATA

SCSI_PASS_THROUGH

typedef struct _SCSI_PASS_THROUGH SCSI_PASS_THROUGH

SCSI_PASS_THROUGH_DIRECT

typedef struct _SCSI_PASS_THROUGH_DIRECT SCSI_PASS_THROUGH_DIRECT

SRB_IO_CONTROL

typedef struct _SRB_IO_CONTROL SRB_IO_CONTROL

Function Documentation

DbgWaitForSingleObject_()

NTSTATUS DbgWaitForSingleObject_	(	IN PVOID	Object,
		IN PLARGE_INTEGER Timeout	OPTIONAL
	)

ScsiClassClaimDevice()

NTSTATUS ScsiClassClaimDevice	(	IN PDEVICE_OBJECT	PortDeviceObject,
		IN PSCSI_INQUIRY_DATA	LunInfo,
		IN BOOLEAN	Release,
		OUT PDEVICE_OBJECT *NewPortDeviceObject	OPTIONAL
	)

Definition at line 4740 of file class2.c.

{
    IO_STATUS_BLOCK    ioStatus;
    PIRP               irp;
    PIO_STACK_LOCATION irpStack;
    KEVENT             event;
    NTSTATUS           status;
    SCSI_REQUEST_BLOCK srb;

    PAGED_CODE();

    if (NewPortDeviceObject != NULL) {
        *NewPortDeviceObject = NULL;
    }

    //
    // Clear the SRB fields.
    //

    RtlZeroMemory(&srb, sizeof(SCSI_REQUEST_BLOCK));

    //
    // Write length to SRB.
    //

    srb.Length = SCSI_REQUEST_BLOCK_SIZE;

    //
    // Set SCSI bus address.
    //

    srb.PathId = LunInfo->PathId;
    srb.TargetId = LunInfo->TargetId;
    srb.Lun = LunInfo->Lun;

    srb.Function = Release ? SRB_FUNCTION_RELEASE_DEVICE :
        SRB_FUNCTION_CLAIM_DEVICE;

    //
    // Set the event object to the unsignaled state.
    // It will be used to signal request completion.
    //

    KeInitializeEvent(&event, NotificationEvent, FALSE);

    //
    // Build synchronous request with no transfer.
    //

    irp = IoBuildDeviceIoControlRequest(IOCTL_SCSI_EXECUTE_NONE,
                                        PortDeviceObject,
                                        NULL,
                                        0,
                                        NULL,
                                        0,
                                        TRUE,
                                        &event,
                                        &ioStatus);

    if (irp == NULL) {

        DebugPrint((1, "ScsiClassClaimDevice: Can't allocate Irp\n"));
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    irpStack = IoGetNextIrpStackLocation(irp);

    //
    // Save SRB address in next stack for port driver.
    //

    irpStack->Parameters.Scsi.Srb = &srb;

    //
    // Set up IRP Address.
    //

    srb.OriginalRequest = irp;

    //
    // Call the port driver with the request and wait for it to complete.
    //

    status = IoCallDriver(PortDeviceObject, irp);
    if (status == STATUS_PENDING) {

        KeWaitForSingleObject(&event, Suspended, KernelMode, FALSE, NULL);
        status = ioStatus.Status;
    }

    //
    // If this is a release request, then just decrement the reference count
    // and return.  The status does not matter.
    //

    if (Release) {

        //ObDereferenceObject(PortDeviceObject);
        return STATUS_SUCCESS;
    }

    if (!NT_SUCCESS(status)) {
        return status;
    }

    ASSERT(srb.DataBuffer != NULL);

    //
    // Reference the new port driver object so that it will not go away while
    // it is being used.
    //

    status = ObReferenceObjectByPointer(srb.DataBuffer,
                                        0,
                                        NULL,
                                        KernelMode );

    if (!NT_SUCCESS(status)) {

        return status;
    }
    ObDereferenceObject(srb.DataBuffer);

    //
    // Return the new port device object pointer.
    //

    if (NewPortDeviceObject != NULL) {
        *NewPortDeviceObject = srb.DataBuffer;
    }

    return status;
}

Referenced by CreateCdRomDeviceObject(), and CreateDiskDeviceObject().

ScsiClassGetAddress()

NTSTATUS ScsiClassGetAddress	(	IN PDEVICE_OBJECT	ClassDeviceObject,
		OUT PSCSI_ADDRESS	Address
	)

ScsiClassGetCapabilities()

NTSTATUS ScsiClassGetCapabilities	(	IN PDEVICE_OBJECT	PortDeviceObject,
		OUT PIO_SCSI_CAPABILITIES *	PortCapabilities
	)

Definition at line 846 of file class2.c.

{
    PIRP            irp;
    IO_STATUS_BLOCK ioStatus;
    KEVENT          event;
    NTSTATUS        status;

    PAGED_CODE();

    //
    // Create notification event object to be used to signal the
    // request completion.
    //

    KeInitializeEvent(&event, NotificationEvent, FALSE);

    //
    // Build the synchronous request  to be sent to the port driver
    // to perform the request.
    //

    irp = IoBuildDeviceIoControlRequest(IOCTL_SCSI_GET_CAPABILITIES,
                                        PortDeviceObject,
                                        NULL,
                                        0,
                                        PortCapabilities,
                                        sizeof(PVOID),
                                        FALSE,
                                        &event,
                                        &ioStatus);

    if (irp == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    //
    // Pass request to port driver and wait for request to complete.
    //

    status = IoCallDriver(PortDeviceObject, irp);

    if (status == STATUS_PENDING) {
        KeWaitForSingleObject(&event, Suspended, KernelMode, FALSE, NULL);
        return(ioStatus.Status);
    }

    return status;

} // end ScsiClassGetCapabilities()

Referenced by FindScsiDisks(), and ScsiCdRomFindDevices().

ScsiClassGetInquiryData()

NTSTATUS ScsiClassGetInquiryData	(	IN PDEVICE_OBJECT	PortDeviceObject,
		IN PSCSI_ADAPTER_BUS_INFO *	ConfigInfo
	)

Referenced by FindScsiDisks(), IsThisAMultiLunDevice(), and ScsiCdRomFindDevices().

ScsiClassInitSrbBusAddr()

VOID ScsiClassInitSrbBusAddr	(	PSCSI_REQUEST_BLOCK	Srb,
		PVOID	DeviceExtension
	)

ScsiClassInternalIoControl()

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

Definition at line 4907 of file class2.c.

{
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
    PSCSI_REQUEST_BLOCK srb;

    ASSERT(*(PULONG)deviceExtension != '2slc');

    //
    // Get a pointer to the SRB.
    //

    srb = irpStack->Parameters.Scsi.Srb;

    //
    // Set SCSI bus address.
    //

    srb->PathId = deviceExtension->PathId;
    srb->TargetId = deviceExtension->TargetId;
    srb->Lun = deviceExtension->Lun;

    //
    // NOTICE:  The SCSI-II specification indicates that this field should be
    // zero; however, some target controllers ignore the logical unit number
    // in the IDENTIFY message and only look at the logical unit number field
    // in the CDB.
    //

    srb->Cdb[1] |= deviceExtension->Lun << 5;

    //
    // Set the parameters in the next stack location.
    //

    irpStack = IoGetNextIrpStackLocation(Irp);

    irpStack->Parameters.Scsi.Srb = srb;
    irpStack->MajorFunction = IRP_MJ_SCSI;
    irpStack->MinorFunction = IRP_MN_SCSI_CLASS;

    IoSetCompletionRoutine(Irp, ClassIoCompletion, NULL, TRUE, TRUE, TRUE);
    return IoCallDriver(deviceExtension->PortDeviceObject, Irp);
}

ScsiClassIoCompletion()

NTSTATUS ScsiClassIoCompletion	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PVOID	Context
	)

ScsiClassReadDeviceInquiryData()

NTSTATUS ScsiClassReadDeviceInquiryData	(	IN PDEVICE_OBJECT	DeviceObject,
		IN BOOLEAN	DirectAccess
	)

ScsiClassReadDriveCapacity()

NTSTATUS ScsiClassReadDriveCapacity

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 1029 of file class2.c.

{
    PDEVICE_EXTENSION   deviceExtension = DeviceObject->DeviceExtension;
    ULONG               retries = 1;
    ULONG               lastSector;
    PCDB                cdb;
    PREAD_CAPACITY_DATA readCapacityBuffer;
    SCSI_REQUEST_BLOCK  srb;
    NTSTATUS            status;

    ASSERT(*(PULONG)deviceExtension != '2slc');

    //
    // Allocate read capacity buffer from nonpaged pool.
    //

    readCapacityBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
                                        sizeof(READ_CAPACITY_DATA));

    if (!readCapacityBuffer) {
        return(STATUS_INSUFFICIENT_RESOURCES);
    }

    RtlZeroMemory(&srb, sizeof(SCSI_REQUEST_BLOCK));

    //
    // Build the read capacity CDB.
    //

    srb.CdbLength = 10;
    cdb = (PCDB)srb.Cdb;

    //
    // Set timeout value from device extension.
    //

    srb.TimeOutValue = deviceExtension->TimeOutValue;

    cdb->CDB10.OperationCode = SCSIOP_READ_CAPACITY;

Retry:

    status = ScsiClassSendSrbSynchronous(DeviceObject,
                                &srb,
                                readCapacityBuffer,
                                sizeof(READ_CAPACITY_DATA),
                                FALSE);

    if (NT_SUCCESS(status)) {

        //
        // Copy sector size from read capacity buffer to device extension
        // in reverse byte order.
        //

        ((PFOUR_BYTE)&deviceExtension->DiskGeometry->Geometry.BytesPerSector)->Byte0 =
            ((PFOUR_BYTE)&readCapacityBuffer->BytesPerBlock)->Byte3;

        ((PFOUR_BYTE)&deviceExtension->DiskGeometry->Geometry.BytesPerSector)->Byte1 =
            ((PFOUR_BYTE)&readCapacityBuffer->BytesPerBlock)->Byte2;

        ((PFOUR_BYTE)&deviceExtension->DiskGeometry->Geometry.BytesPerSector)->Byte2 =
            ((PFOUR_BYTE)&readCapacityBuffer->BytesPerBlock)->Byte1;

        ((PFOUR_BYTE)&deviceExtension->DiskGeometry->Geometry.BytesPerSector)->Byte3 =
            ((PFOUR_BYTE)&readCapacityBuffer->BytesPerBlock)->Byte0;

        //
        // Copy last sector in reverse byte order.
        //

        ((PFOUR_BYTE)&lastSector)->Byte0 =
            ((PFOUR_BYTE)&readCapacityBuffer->LogicalBlockAddress)->Byte3;

        ((PFOUR_BYTE)&lastSector)->Byte1 =
            ((PFOUR_BYTE)&readCapacityBuffer->LogicalBlockAddress)->Byte2;

        ((PFOUR_BYTE)&lastSector)->Byte2 =
            ((PFOUR_BYTE)&readCapacityBuffer->LogicalBlockAddress)->Byte1;

        ((PFOUR_BYTE)&lastSector)->Byte3 =
            ((PFOUR_BYTE)&readCapacityBuffer->LogicalBlockAddress)->Byte0;

        //
        // Calculate sector to byte shift.
        //

        WHICH_BIT(deviceExtension->DiskGeometry->Geometry.BytesPerSector, deviceExtension->SectorShift);

        DebugPrint((2,"SCSI ScsiClassReadDriveCapacity: Sector size is %d\n",
            deviceExtension->DiskGeometry->Geometry.BytesPerSector));

        DebugPrint((2,"SCSI ScsiClassReadDriveCapacity: Number of Sectors is %d\n",
            lastSector + 1));

        //
        // Calculate media capacity in bytes.
        //

        deviceExtension->PartitionLength.QuadPart = (LONGLONG)(lastSector + 1);

        //
        // Calculate number of cylinders.
        //

        deviceExtension->DiskGeometry->Geometry.Cylinders.QuadPart = (LONGLONG)((lastSector + 1)/(DEFAULT_SECTORS_PER_TRACK * DEFAULT_TRACKS_PER_CYLINDER));

        deviceExtension->PartitionLength.QuadPart =
            (deviceExtension->PartitionLength.QuadPart << deviceExtension->SectorShift);

        if (DeviceObject->Characteristics & FILE_REMOVABLE_MEDIA) {

            //
            // This device supports removable media.
            //

            deviceExtension->DiskGeometry->Geometry.MediaType = RemovableMedia;

        } else {

            //
            // Assume media type is fixed disk.
            //

            deviceExtension->DiskGeometry->Geometry.MediaType = FixedMedia;
        }

        //
        // Assume sectors per track are DEFAULT_SECTORS_PER_TRACK;
        //

        deviceExtension->DiskGeometry->Geometry.SectorsPerTrack = DEFAULT_SECTORS_PER_TRACK;

        //
        // Assume tracks per cylinder (number of heads) is DEFAULT_TRACKS_PER_CYLINDER.
        //

        deviceExtension->DiskGeometry->Geometry.TracksPerCylinder = DEFAULT_TRACKS_PER_CYLINDER;
    }

    if (status == STATUS_VERIFY_REQUIRED) {

        //
        // Routine ScsiClassSendSrbSynchronous does not retry
        // requests returned with this status.
        // Read Capacities should be retried
        // anyway.
        //

        if (retries--) {

            //
            // Retry request.
            //

            goto Retry;
        }
    }

    if (!NT_SUCCESS(status)) {

        //
        // If the read capacity fails, set the geometry to reasonable parameter
        // so things don't fail at unexpected places.  Zero the geometry
        // except for the bytes per sector and sector shift.
        //

        RtlZeroMemory(deviceExtension->DiskGeometry, sizeof(DISK_GEOMETRY_EX));
        deviceExtension->DiskGeometry->Geometry.BytesPerSector = 512;
        deviceExtension->SectorShift = 9;
        deviceExtension->PartitionLength.QuadPart = (LONGLONG) 0;

        if (DeviceObject->Characteristics & FILE_REMOVABLE_MEDIA) {

            //
            // This device supports removable media.
            //

            deviceExtension->DiskGeometry->Geometry.MediaType = RemovableMedia;

        } else {

            //
            // Assume media type is fixed disk.
            //

            deviceExtension->DiskGeometry->Geometry.MediaType = FixedMedia;
        }
    }

    //
    // Deallocate read capacity buffer.
    //

    ExFreePool(readCapacityBuffer);

    return status;

} // end ScsiClassReadDriveCapacity()

Referenced by CreateCdRomDeviceObject(), CreateDiskDeviceObject(), ScsiDiskDeviceControl(), and UpdateRemovableGeometry().

ScsiClassReleaseQueue()

VOID ScsiClassReleaseQueue

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 1253 of file class2.c.

{
    PIO_STACK_LOCATION irpStack;
    PIRP irp;
    PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
    PCOMPLETION_CONTEXT context;
    PSCSI_REQUEST_BLOCK srb;
    KIRQL currentIrql;

    ASSERT(*(PULONG)deviceExtension != '2slc');

    //
    // Allocate context from nonpaged pool.
    //

    context = ExAllocatePool(NonPagedPoolMustSucceed,
                             sizeof(COMPLETION_CONTEXT));

    //
    // Save the device object in the context for use by the completion
    // routine.
    //

    context->DeviceObject = DeviceObject;
    srb = &context->Srb;

    //
    // Zero out srb.
    //

    RtlZeroMemory(srb, SCSI_REQUEST_BLOCK_SIZE);

    //
    // Write length to SRB.
    //

    srb->Length = SCSI_REQUEST_BLOCK_SIZE;

    //
    // Set up SCSI bus address.
    //

    srb->PathId = deviceExtension->PathId;
    srb->TargetId = deviceExtension->TargetId;
    srb->Lun = deviceExtension->Lun;

    //
    // If this device is removable then flush the queue.  This will also
    // release it.
    //

    if (DeviceObject->Characteristics & FILE_REMOVABLE_MEDIA) {

       srb->Function = SRB_FUNCTION_FLUSH_QUEUE;

    } else {

       srb->Function = SRB_FUNCTION_RELEASE_QUEUE;

    }

    //
    // Build the asynchronous request to be sent to the port driver.
    //

    irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);

    if(irp == NULL) {

        //
        // We have no better way of dealing with this at the moment
        //

        KeBugCheck((ULONG)0x0000002DL);

    }

    IoSetCompletionRoutine(irp,
                           (PIO_COMPLETION_ROUTINE)ScsiClassAsynchronousCompletion,
                           context,
                           TRUE,
                           TRUE,
                           TRUE);

    irpStack = IoGetNextIrpStackLocation(irp);

    irpStack->MajorFunction = IRP_MJ_SCSI;

    srb->OriginalRequest = irp;

    //
    // Store the SRB address in next stack for port driver.
    //

    irpStack->Parameters.Scsi.Srb = srb;

    //
    // Since this routine can cause outstanding requests to be completed, and
    // calling a completion routine at < DISPATCH_LEVEL is dangerous (if they
    // call IoStartNextPacket we will bugcheck) raise up to dispatch level before
    // issuing the request
    //

    currentIrql = KeGetCurrentIrql();

    if(currentIrql < DISPATCH_LEVEL) {
        KeRaiseIrql(DISPATCH_LEVEL, &currentIrql);
        IoCallDriver(deviceExtension->PortDeviceObject, irp);
        KeLowerIrql(currentIrql);
    } else {
        IoCallDriver(deviceExtension->PortDeviceObject, irp);
    }

    return;

} // end ScsiClassReleaseQueue()

Referenced by CdRomDeviceControlCompletion(), CdRomMediaChangeCompletion(), CdRomSetVolumeIntermediateCompletion(), CdRomSwitchModeCompletion(), CdRomUpdateGeometryCompletion(), CdRomXACompletion(), and ToshibaProcessErrorCompletion().

ScsiClassRemoveDevice()

NTSTATUS ScsiClassRemoveDevice	(	IN PDEVICE_OBJECT	PortDeviceObject,
		IN UCHAR	PathId,
		IN UCHAR	TargetId,
		IN UCHAR	Lun
	)

ScsiClassSendSrbSynchronous()

NTSTATUS ScsiClassSendSrbSynchronous	(	IN PDEVICE_OBJECT	TargetDeviceObject,
		IN PSCSI_REQUEST_BLOCK	_srb,
		IN PKEVENT	event
	)

Referenced by CreateCdRomDeviceObject(), IsThisAnAtapiChanger(), ScanForSpecial(), ScsiDiskDeviceControl(), ScsiDiskModeSelect(), and ScsiDiskShutdownFlush().