cdrom.c File Reference

#include "precomp.h"
#include <ntddk.h>
#include <scsi.h>
#include <ntdddisk.h>
#include <ntddcdrm.h>
#include <include/class2.h>
#include <stdio.h>
#include <debug.h>

Include dependency graph for cdrom.c:

Go to the source code of this file.

Classes
struct	_XA_CONTEXT
struct	_ERROR_RECOVERY_DATA
struct	_ERROR_RECOVERY_DATA10
struct	_CDROM_DATA

Macros
#define	CDB12GENERIC_LENGTH   12
#define	DEVICE_EXTENSION_SIZE   sizeof(DEVICE_EXTENSION) + sizeof(CDROM_DATA)
#define	SCSI_CDROM_TIMEOUT   10
#define	SCSI_CHANGER_BONUS_TIMEOUT   10
#define	HITACHI_MODE_DATA_SIZE   12
#define	MODE_DATA_SIZE   64
#define	RAW_SECTOR_SIZE   2352
#define	COOKED_SECTOR_SIZE   2048
#define	MEDIA_CHANGE_DEFAULT_TIME   4
#define	CDROM_SRB_LIST_SIZE   4
#define	PLAY_ACTIVE(DeviceExtension)   (((PCDROM_DATA)(DeviceExtension + 1))->PlayActive)
#define	MSF_TO_LBA(Minutes, Seconds, Frames)   (ULONG)((60 * 75 * (Minutes)) + (75 * (Seconds)) + ((Frames) - 150))
#define	LBA_TO_MSF(Lba, Minutes, Seconds, Frames)
#define	DEC_TO_BCD(x)   (((x / 10) << 4) + (x % 10))
#define	XA_USE_6_BYTE   0x01
#define	XA_USE_10_BYTE   0x02
#define	XA_USE_READ_CD   0x04
#define	XA_NOT_SUPPORTED   0x08
#define	PLEXTOR_CDDA   0x10
#define	NEC_CDDA   0x20
#define	ANY_SECTOR   0
#define	CD_DA_SECTOR   1
#define	YELLOW_MODE1_SECTOR   2
#define	YELLOW_MODE2_SECTOR   3
#define	FORM2_MODE1_SECTOR   4
#define	FORM2_MODE2_SECTOR   5
#define	ITEMS_TO_QUERY   2 /* always 1 greater than what is searched */

Typedefs
typedef struct _XA_CONTEXT	XA_CONTEXT
typedef struct _XA_CONTEXT *	PXA_CONTEXT
typedef struct _ERROR_RECOVERY_DATA	ERROR_RECOVERY_DATA
typedef struct _ERROR_RECOVERY_DATA *	PERROR_RECOVERY_DATA
typedef struct _ERROR_RECOVERY_DATA10	ERROR_RECOVERY_DATA10
typedef struct _ERROR_RECOVERY_DATA10 *	PERROR_RECOVERY_DATA10
typedef struct _CDROM_DATA	CDROM_DATA
typedef struct _CDROM_DATA *	PCDROM_DATA

Functions
NTSTATUS NTAPI	DriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
BOOLEAN NTAPI	ScsiCdRomFindDevices (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath, IN PCLASS_INIT_DATA InitializationData, IN PDEVICE_OBJECT PortDeviceObject, IN ULONG PortNumber)
NTSTATUS NTAPI	ScsiCdRomOpenClose (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	ScsiCdRomReadVerification (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	ScsiCdRomSwitchMode (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN PIRP OriginalRequest)
NTSTATUS NTAPI	CdRomDeviceControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	CdRomDeviceControlCompletion (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
NTSTATUS NTAPI	CdRomSetVolumeIntermediateCompletion (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
NTSTATUS NTAPI	CdRomSwitchModeCompletion (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
NTSTATUS NTAPI	CdRomXACompletion (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
NTSTATUS NTAPI	CdRomClassIoctlCompletion (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
VOID NTAPI	ScsiCdRomStartIo (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI	CdRomTickHandler (IN PDEVICE_OBJECT DeviceObject, IN PVOID Context)
BOOLEAN NTAPI	CdRomCheckRegistryForMediaChangeValue (IN PUNICODE_STRING RegistryPath, IN ULONG DeviceNumber)
NTSTATUS NTAPI	CdRomUpdateCapacity (IN PDEVICE_EXTENSION DeviceExtension, IN PIRP IrpToComplete, IN OPTIONAL PKEVENT IoctlEvent)
NTSTATUS NTAPI	CreateCdRomDeviceObject (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PortDeviceObject, IN ULONG PortNumber, IN PULONG DeviceCount, PIO_SCSI_CAPABILITIES PortCapabilities, IN PSCSI_INQUIRY_DATA LunInfo, IN PCLASS_INIT_DATA InitializationData, IN PUNICODE_STRING RegistryPath)
VOID NTAPI	ScanForSpecial (PDEVICE_OBJECT DeviceObject, PINQUIRYDATA InquiryData, PIO_SCSI_CAPABILITIES PortCapabilities)
BOOLEAN NTAPI	CdRomIsPlayActive (IN PDEVICE_OBJECT DeviceObject)
VOID NTAPI	HitachProcessError (PDEVICE_OBJECT DeviceObject, PSCSI_REQUEST_BLOCK Srb, NTSTATUS *Status, BOOLEAN *Retry)
VOID NTAPI	ToshibaProcessError (PDEVICE_OBJECT DeviceObject, PSCSI_REQUEST_BLOCK Srb, NTSTATUS *Status, BOOLEAN *Retry)
BOOLEAN NTAPI	IsThisAnAtapiChanger (IN PDEVICE_OBJECT DeviceObject, OUT PULONG DiscsPresent)
BOOLEAN NTAPI	IsThisASanyo (IN PDEVICE_OBJECT DeviceObject, IN UCHAR PathId, IN UCHAR TargetId)
BOOLEAN NTAPI	IsThisAMultiLunDevice (IN PDEVICE_OBJECT DeviceObject, IN PDEVICE_OBJECT PortDeviceObject)
VOID NTAPI	CdRomCreateNamedEvent (IN PDEVICE_EXTENSION DeviceExtension, IN ULONG DeviceNumber)
VOID NTAPI	ReportToMountMgr (IN PDEVICE_OBJECT CdDeviceObject)
NTSTATUS NTAPI	CreateCdRomDeviceObject (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PortDeviceObject, IN ULONG PortNumber, IN PULONG DeviceCount, IN PIO_SCSI_CAPABILITIES PortCapabilities, IN PSCSI_INQUIRY_DATA LunInfo, IN PCLASS_INIT_DATA InitializationData, IN PUNICODE_STRING RegistryPath)
NTSTATUS NTAPI	ToshibaProcessErrorCompletion (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
NTSTATUS NTAPI	CdRomMediaChangeCompletion (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
NTSTATUS NTAPI	CdRomUpdateGeometryCompletion (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)

Variables
IO_COMPLETION_ROUTINE	CdRomDeviceControlCompletion
IO_COMPLETION_ROUTINE	CdRomSetVolumeIntermediateCompletion
IO_COMPLETION_ROUTINE	CdRomSwitchModeCompletion
IO_COMPLETION_ROUTINE	CdRomXACompletion
IO_COMPLETION_ROUTINE	CdRomClassIoctlCompletion
IO_COMPLETION_ROUTINE	ToshibaProcessErrorCompletion
ULONG	NoLoad = 0
IO_COMPLETION_ROUTINE	CdRomMediaChangeCompletion
IO_COMPLETION_ROUTINE	CdRomUpdateGeometryCompletion

Macro Definition Documentation

ANY_SECTOR

#define ANY_SECTOR   0

Definition at line 220 of file cdrom.c.

CD_DA_SECTOR

#define CD_DA_SECTOR   1

Definition at line 221 of file cdrom.c.

CDB12GENERIC_LENGTH

#define CDB12GENERIC_LENGTH   12

Definition at line 21 of file cdrom.c.

CDROM_SRB_LIST_SIZE

#define CDROM_SRB_LIST_SIZE   4

Definition at line 177 of file cdrom.c.

COOKED_SECTOR_SIZE

#define COOKED_SECTOR_SIZE   2048

Definition at line 175 of file cdrom.c.

DEC_TO_BCD

#define DEC_TO_BCD

(

x

)

(((x / 10) << 4) + (x % 10))

Definition at line 202 of file cdrom.c.

DEVICE_EXTENSION_SIZE

#define DEVICE_EXTENSION_SIZE   sizeof(DEVICE_EXTENSION) + sizeof(CDROM_DATA)

Definition at line 169 of file cdrom.c.

FORM2_MODE1_SECTOR

#define FORM2_MODE1_SECTOR   4

Definition at line 224 of file cdrom.c.

FORM2_MODE2_SECTOR

#define FORM2_MODE2_SECTOR   5

Definition at line 225 of file cdrom.c.

HITACHI_MODE_DATA_SIZE

#define HITACHI_MODE_DATA_SIZE   12

Definition at line 172 of file cdrom.c.

ITEMS_TO_QUERY

#define ITEMS_TO_QUERY   2 /* always 1 greater than what is searched */

LBA_TO_MSF

#define LBA_TO_MSF	(		Lba,
			Minutes,
			Seconds,
			Frames
	)

Value:

{                                                            \
    (Minutes) = (UCHAR)(Lba  / (60 * 75));                   \
    (Seconds) = (UCHAR)((Lba % (60 * 75)) / 75);             \
    (Frames)  = (UCHAR)((Lba % (60 * 75)) % 75);             \
}

Definition at line 195 of file cdrom.c.

MEDIA_CHANGE_DEFAULT_TIME

#define MEDIA_CHANGE_DEFAULT_TIME   4

Definition at line 176 of file cdrom.c.

MODE_DATA_SIZE

#define MODE_DATA_SIZE   64

Definition at line 173 of file cdrom.c.

MSF_TO_LBA

#define MSF_TO_LBA	(		Minutes,
			Seconds,
			Frames
	)		(ULONG)((60 * 75 * (Minutes)) + (75 * (Seconds)) + ((Frames) - 150))

Definition at line 192 of file cdrom.c.

NEC_CDDA

#define NEC_CDDA   0x20

Definition at line 214 of file cdrom.c.

PLAY_ACTIVE

#define PLAY_ACTIVE

(

DeviceExtension

)

(((PCDROM_DATA)(DeviceExtension + 1))->PlayActive)

Definition at line 190 of file cdrom.c.

PLEXTOR_CDDA

#define PLEXTOR_CDDA   0x10

Definition at line 213 of file cdrom.c.

RAW_SECTOR_SIZE

#define RAW_SECTOR_SIZE   2352

Definition at line 174 of file cdrom.c.

SCSI_CDROM_TIMEOUT

#define SCSI_CDROM_TIMEOUT   10

Definition at line 170 of file cdrom.c.

SCSI_CHANGER_BONUS_TIMEOUT

#define SCSI_CHANGER_BONUS_TIMEOUT   10

Definition at line 171 of file cdrom.c.

XA_NOT_SUPPORTED

#define XA_NOT_SUPPORTED   0x08

Definition at line 211 of file cdrom.c.

XA_USE_10_BYTE

#define XA_USE_10_BYTE   0x02

Definition at line 209 of file cdrom.c.

XA_USE_6_BYTE

#define XA_USE_6_BYTE   0x01

Definition at line 208 of file cdrom.c.

XA_USE_READ_CD

#define XA_USE_READ_CD   0x04

Definition at line 210 of file cdrom.c.

YELLOW_MODE1_SECTOR

#define YELLOW_MODE1_SECTOR   2

Definition at line 222 of file cdrom.c.

YELLOW_MODE2_SECTOR

#define YELLOW_MODE2_SECTOR   3

Definition at line 223 of file cdrom.c.

Typedef Documentation

CDROM_DATA

typedef struct _CDROM_DATA CDROM_DATA

ERROR_RECOVERY_DATA

typedef struct _ERROR_RECOVERY_DATA ERROR_RECOVERY_DATA

ERROR_RECOVERY_DATA10

typedef struct _ERROR_RECOVERY_DATA10 ERROR_RECOVERY_DATA10

PCDROM_DATA

typedef struct _CDROM_DATA * PCDROM_DATA

PERROR_RECOVERY_DATA

typedef struct _ERROR_RECOVERY_DATA * PERROR_RECOVERY_DATA

PERROR_RECOVERY_DATA10

typedef struct _ERROR_RECOVERY_DATA10 * PERROR_RECOVERY_DATA10

PXA_CONTEXT

typedef struct _XA_CONTEXT * PXA_CONTEXT

XA_CONTEXT

typedef struct _XA_CONTEXT XA_CONTEXT

Function Documentation

CdRomCheckRegistryForMediaChangeValue()

BOOLEAN NTAPI CdRomCheckRegistryForMediaChangeValue	(	IN PUNICODE_STRING	RegistryPath,
		IN ULONG	DeviceNumber
	)

Definition at line 6386 of file cdrom.c.

{
#define ITEMS_TO_QUERY 2 /* always 1 greater than what is searched */
    PRTL_QUERY_REGISTRY_TABLE parameters = NULL;
    NTSTATUS          status;
    LONG              zero = 0;

    LONG              tmp = 0;
    LONG              doRun = 0;

    CHAR              buf[32];
    ANSI_STRING       paramNum;

    UNICODE_STRING    paramStr;

    UNICODE_STRING    paramSuffix;
    UNICODE_STRING    paramPath;
    UNICODE_STRING    paramDevPath;

    //
    // First append \Parameters to the passed in registry path
    //

    RtlInitUnicodeString(&paramStr, L"\\Parameters");

    RtlInitUnicodeString(&paramPath, NULL);

    paramPath.MaximumLength = RegistryPath->Length +
                              paramStr.Length +
                              sizeof(WCHAR);

    paramPath.Buffer = ExAllocatePool(PagedPool, paramPath.MaximumLength);

    if(!paramPath.Buffer) {

        DebugPrint((1,"CdRomCheckRegAP: couldn't allocate paramPath\n"));

        return FALSE;
    }

    RtlZeroMemory(paramPath.Buffer, paramPath.MaximumLength);
    RtlAppendUnicodeToString(&paramPath, RegistryPath->Buffer);
    RtlAppendUnicodeToString(&paramPath, paramStr.Buffer);

    DebugPrint((2, "CdRomCheckRegAP: paramPath [%d] = %ws\n",
                paramPath.Length,
                paramPath.Buffer));

    //
    // build a counted ANSI string that contains
    // the suffix for the path
    //

    sprintf(buf, "\\Device%lu", DeviceNumber);
    RtlInitAnsiString(&paramNum, buf);

    //
    // Next convert this into a unicode string
    //

    status = RtlAnsiStringToUnicodeString(&paramSuffix, &paramNum, TRUE);

    if(!NT_SUCCESS(status)) {
        DebugPrint((1,"CdRomCheckRegAP: couldn't convert paramNum to paramSuffix\n"));
        ExFreePool(paramPath.Buffer);
        return FALSE;
    }

    RtlInitUnicodeString(&paramDevPath, NULL);

    //
    // now build the device specific path
    //

    paramDevPath.MaximumLength = paramPath.Length +
                                 paramSuffix.Length +
                                 sizeof(WCHAR);
    paramDevPath.Buffer = ExAllocatePool(PagedPool, paramDevPath.MaximumLength);

    if(!paramDevPath.Buffer) {
        RtlFreeUnicodeString(&paramSuffix);
        ExFreePool(paramPath.Buffer);
        return FALSE;
    }

    RtlZeroMemory(paramDevPath.Buffer, paramDevPath.MaximumLength);
    RtlAppendUnicodeToString(&paramDevPath, paramPath.Buffer);
    RtlAppendUnicodeToString(&paramDevPath, paramSuffix.Buffer);

    DebugPrint((2, "CdRomCheckRegAP: paramDevPath [%d] = %ws\n",
                paramPath.Length,
                paramPath.Buffer));

    parameters = ExAllocatePool(NonPagedPool,
                                sizeof(RTL_QUERY_REGISTRY_TABLE)*ITEMS_TO_QUERY);

    if (parameters) {

        //
        // Check for the Autorun value.
        //

        RtlZeroMemory(parameters,
                      (sizeof(RTL_QUERY_REGISTRY_TABLE)*ITEMS_TO_QUERY));

        parameters[0].Flags         = RTL_QUERY_REGISTRY_DIRECT;
        parameters[0].Name          = L"Autorun";
        parameters[0].EntryContext  = &doRun;
        parameters[0].DefaultType   = REG_DWORD;
        parameters[0].DefaultData   = &zero;
        parameters[0].DefaultLength = sizeof(ULONG);

        status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
                                        RegistryPath->Buffer,
                                        parameters,
                                        NULL,
                                        NULL);

        DebugPrint((2, "CdRomCheckRegAP: cdrom/Autorun flag = %d\n", doRun));

        RtlZeroMemory(parameters,
                      (sizeof(RTL_QUERY_REGISTRY_TABLE)*ITEMS_TO_QUERY));

        parameters[0].Flags         = RTL_QUERY_REGISTRY_DIRECT;
        parameters[0].Name          = L"Autorun";
        parameters[0].EntryContext  = &tmp;
        parameters[0].DefaultType   = REG_DWORD;
        parameters[0].DefaultData   = &doRun;
        parameters[0].DefaultLength = sizeof(ULONG);

        status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
                                        paramPath.Buffer,
                                        parameters,
                                        NULL,
                                        NULL);

        DebugPrint((2, "CdRomCheckRegAP: cdrom/parameters/autorun flag = %d\n", tmp));

        RtlZeroMemory(parameters,
                      (sizeof(RTL_QUERY_REGISTRY_TABLE) * ITEMS_TO_QUERY));

        parameters[0].Flags         = RTL_QUERY_REGISTRY_DIRECT;
        parameters[0].Name          = L"Autorun";
        parameters[0].EntryContext  = &doRun;
        parameters[0].DefaultType   = REG_DWORD;
        parameters[0].DefaultData   = &tmp;
        parameters[0].DefaultLength = sizeof(ULONG);

        status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
                                        paramDevPath.Buffer,
                                        parameters,
                                        NULL,
                                        NULL);

        DebugPrint((1, "CdRomCheckRegAP: cdrom/parameters/device%d/autorun flag = %d\n", DeviceNumber, doRun));

        ExFreePool(parameters);

    }

    ExFreePool(paramPath.Buffer);
    ExFreePool(paramDevPath.Buffer);
    RtlFreeUnicodeString(&paramSuffix);

    DebugPrint((1, "CdRomCheckRegAP: Autoplay for device %d is %s\n",
                DeviceNumber,
                (doRun ? "on" : "off")));

    if(doRun) {
        return TRUE;
    }

    return FALSE;
}

Referenced by CreateCdRomDeviceObject().

CdRomClassIoctlCompletion()

NTSTATUS NTAPI CdRomClassIoctlCompletion	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PVOID	Context
	)

Definition at line 7322 of file cdrom.c.

{
    PKEVENT syncEvent = (PKEVENT) Context;

    DebugPrint((2, "CdRomClassIoctlCompletion: setting event for irp %#08lx\n",
                Irp
                ));

    KeSetEvent(syncEvent, IO_DISK_INCREMENT, FALSE);

    return STATUS_MORE_PROCESSING_REQUIRED;
}

CdRomCreateNamedEvent()

VOID NTAPI CdRomCreateNamedEvent	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN ULONG	DeviceNumber
	)

Definition at line 674 of file cdrom.c.

{
    UNICODE_STRING    unicodeString;
    OBJECT_ATTRIBUTES objectAttributes;
    CCHAR             eventNameBuffer[MAXIMUM_FILENAME_LENGTH];
    STRING            eventNameString;
    HANDLE            handle;
    NTSTATUS          status;


    sprintf(eventNameBuffer,"\\Device\\MediaChangeEvent%ld",
            DeviceNumber);

    RtlInitString(&eventNameString,
                  eventNameBuffer);

    status = RtlAnsiStringToUnicodeString(&unicodeString,
                                          &eventNameString,
                                          TRUE);

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

    InitializeObjectAttributes(&objectAttributes,
                               &unicodeString,
                               OBJ_PERMANENT | OBJ_CASE_INSENSITIVE | OBJ_OPENIF,
                               NULL,
                               NULL);

    DeviceExtension->MediaChangeEvent = IoCreateSynchronizationEvent(&unicodeString,
                                                                     &handle);
    DeviceExtension->MediaChangeEventHandle = handle;

    KeClearEvent(DeviceExtension->MediaChangeEvent);

    RtlFreeUnicodeString(&unicodeString);
}

Referenced by CreateCdRomDeviceObject().

CdRomDeviceControl()

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

Definition at line 4686 of file cdrom.c.

{
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PIO_STACK_LOCATION nextStack;
    PKEVENT            deviceControlEvent;
    PDEVICE_EXTENSION  deviceExtension = DeviceObject->DeviceExtension;
    PCDROM_DATA        cdData = (PCDROM_DATA)(deviceExtension+1);
    SCSI_REQUEST_BLOCK srb;
    NTSTATUS status;
    KIRQL    irql;

    ULONG ioctlCode;
    ULONG baseCode;
    ULONG functionCode;

RetryControl:

    //
    // Zero the SRB on stack.
    //

    RtlZeroMemory(&srb, sizeof(SCSI_REQUEST_BLOCK));

    Irp->IoStatus.Information = 0;

    //
    // if this is a class driver ioctl then we need to change the base code
    // to IOCTL_CDROM_BASE so that the switch statement can handle it.
    //
    // WARNING - currently the scsi class ioctl function codes are between
    // 0x200 & 0x300.  this routine depends on that fact
    //

    ioctlCode = irpStack->Parameters.DeviceIoControl.IoControlCode;
    baseCode = ioctlCode >> 16;
    functionCode = (ioctlCode & (~0xffffc003)) >> 2;

    DebugPrint((1, "CdRomDeviceControl: Ioctl Code = %#08lx, Base Code = %#lx,"
                   " Function Code = %#lx\n",
                ioctlCode,
                baseCode,
                functionCode
              ));

    if((functionCode >= 0x200) && (functionCode <= 0x300)) {

        ioctlCode = (ioctlCode & 0x0000ffff) | CTL_CODE(IOCTL_CDROM_BASE, 0, 0, 0);

        DebugPrint((1, "CdRomDeviceControl: Class Code - new ioctl code is %#08lx\n",
                    ioctlCode));

        irpStack->Parameters.DeviceIoControl.IoControlCode = ioctlCode;

    }

    switch (ioctlCode) {

    case IOCTL_CDROM_RAW_READ: {

        LARGE_INTEGER  startingOffset;
        ULONG          transferBytes;
        PRAW_READ_INFO rawReadInfo = (PRAW_READ_INFO)irpStack->Parameters.DeviceIoControl.Type3InputBuffer;
        PUCHAR         userData = (PUCHAR)Irp->AssociatedIrp.SystemBuffer;

        //
        // Ensure that XA reads are supported.
        //

        if (cdData->XAFlags & XA_NOT_SUPPORTED) {

            DebugPrint((1,
                        "CdRomDeviceControl: XA Reads not supported. Flags (%x)\n",
                        cdData->XAFlags));

            status = STATUS_INVALID_DEVICE_REQUEST;
            break;
        }

        //
        // Check that ending sector is on disc and buffers are there and of
        // correct size.
        //

        if (rawReadInfo == NULL) {

            //
            //  Called from user space. Validate the buffers.
            //

            rawReadInfo = (PRAW_READ_INFO)userData;
            irpStack->Parameters.DeviceIoControl.Type3InputBuffer = (PVOID)userData;

            if (rawReadInfo == NULL) {

                DebugPrint((1,"CdRomDeviceControl: Invalid I/O parameters for XA Read (No extent info\n"));

                Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;

                IoCompleteRequest(Irp, IO_NO_INCREMENT);
                return STATUS_INVALID_PARAMETER;
            }

            if (irpStack->Parameters.DeviceIoControl.InputBufferLength != sizeof(RAW_READ_INFO)) {

                DebugPrint((1,"CdRomDeviceControl: Invalid I/O parameters for XA Read (Invalid info buffer\n"));

                Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;

                IoCompleteRequest(Irp, IO_NO_INCREMENT);
                return STATUS_INVALID_PARAMETER;
            }
        }

        startingOffset.QuadPart = rawReadInfo->DiskOffset.QuadPart;
        transferBytes = rawReadInfo->SectorCount * RAW_SECTOR_SIZE;

        if (irpStack->Parameters.DeviceIoControl.OutputBufferLength < transferBytes) {

            DebugPrint((1,"CdRomDeviceControl: Invalid I/O parameters for XA Read (Bad buffer size)\n"));

            //
            // Fail request with status of invalid parameters.
            //

            Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;

            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return STATUS_INVALID_PARAMETER;
        }

        if ((startingOffset.QuadPart + transferBytes) > deviceExtension->PartitionLength.QuadPart) {

            DebugPrint((1,"CdRomDeviceControl: Invalid I/O parameters for XA Read (Request Out of Bounds)\n"));

            //
            // Fail request with status of invalid parameters.
            //

            status = STATUS_INVALID_PARAMETER;
            break;
        }

        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject, Irp, NULL, NULL);

        return STATUS_PENDING;
    }

    case IOCTL_DISK_GET_DRIVE_GEOMETRY:
    case IOCTL_CDROM_GET_DRIVE_GEOMETRY: {

        DebugPrint((2,"CdRomDeviceControl: Get drive geometry\n"));

        if ( irpStack->Parameters.DeviceIoControl.OutputBufferLength <
            sizeof( DISK_GEOMETRY ) ) {

            status = STATUS_INFO_LENGTH_MISMATCH;
            break;
        }

        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject,Irp, NULL,NULL);

        return STATUS_PENDING;
    }

    case IOCTL_DISK_GET_DRIVE_GEOMETRY_EX:
    case IOCTL_CDROM_GET_DRIVE_GEOMETRY_EX: {

        DebugPrint((2,"CdRomDeviceControl: Get drive geometry ex\n"));

        if ( irpStack->Parameters.DeviceIoControl.OutputBufferLength <
            sizeof( DISK_GEOMETRY_EX ) ) {

            status = STATUS_INFO_LENGTH_MISMATCH;
            break;
        }

        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject,Irp, NULL,NULL);

        return STATUS_PENDING;
    }

    case IOCTL_DISK_GET_LENGTH_INFO: {

        DebugPrint((2,"CdRomDeviceControl: Get length info\n"));

        if ( irpStack->Parameters.DeviceIoControl.OutputBufferLength <
            sizeof( GET_LENGTH_INFORMATION ) ) {

            status = STATUS_INFO_LENGTH_MISMATCH;
            break;
        }

        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject,Irp, NULL,NULL);

        return STATUS_PENDING;
    }

    case IOCTL_CDROM_GET_LAST_SESSION:
    case IOCTL_CDROM_READ_TOC:  {

        //
        // If the cd is playing music then reject this request.
        //

        if (CdRomIsPlayActive(DeviceObject)) {
            Irp->IoStatus.Status = STATUS_DEVICE_BUSY;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return STATUS_DEVICE_BUSY;
        }

        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject, Irp, NULL, NULL);

        return STATUS_PENDING;
    }

    case IOCTL_CDROM_PLAY_AUDIO_MSF: {

        //
        // Play Audio MSF
        //

        DebugPrint((2,"CdRomDeviceControl: Play audio MSF\n"));

        if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
            sizeof(CDROM_PLAY_AUDIO_MSF)) {

            //
            // Indicate unsuccessful status.
            //

            status = STATUS_BUFFER_TOO_SMALL;
            break;
        }

        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject, Irp, NULL, NULL);

        return STATUS_PENDING;
    }

    case IOCTL_CDROM_SEEK_AUDIO_MSF: {


        //
        // Seek Audio MSF
        //

        DebugPrint((2,"CdRomDeviceControl: Seek audio MSF\n"));

        if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
            sizeof(CDROM_SEEK_AUDIO_MSF)) {

            //
            // Indicate unsuccessful status.
            //

            status = STATUS_BUFFER_TOO_SMALL;
            break;
        } else {
            IoMarkIrpPending(Irp);
            IoStartPacket(DeviceObject, Irp, NULL, NULL);

            return STATUS_PENDING;

        }
    }

    case IOCTL_CDROM_PAUSE_AUDIO: {

        //
        // Pause audio
        //

        DebugPrint((2, "CdRomDeviceControl: Pause audio\n"));

        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject, Irp, NULL, NULL);

        return STATUS_PENDING;

        break;
    }

    case IOCTL_CDROM_RESUME_AUDIO: {

        //
        // Resume audio
        //

        DebugPrint((2, "CdRomDeviceControl: Resume audio\n"));

        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject, Irp, NULL, NULL);

        return STATUS_PENDING;
    }

    case IOCTL_CDROM_READ_Q_CHANNEL: {

        if(irpStack->Parameters.DeviceIoControl.InputBufferLength <
            sizeof(CDROM_SUB_Q_DATA_FORMAT)) {

            status = STATUS_BUFFER_TOO_SMALL;
            Irp->IoStatus.Information = 0;
            break;
        }

        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject, Irp, NULL, NULL);

        return STATUS_PENDING;
    }

    case IOCTL_CDROM_GET_CONTROL: {

        DebugPrint((2, "CdRomDeviceControl: Get audio control\n"));

        //
        // Verify user buffer is large enough for the data.
        //

        if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
            sizeof(CDROM_AUDIO_CONTROL)) {

            //
            // Indicate unsuccessful status and no data transferred.
            //

            status = STATUS_BUFFER_TOO_SMALL;
            Irp->IoStatus.Information = 0;
            break;

        } else {

            IoMarkIrpPending(Irp);
            IoStartPacket(DeviceObject, Irp, NULL, NULL);

            return STATUS_PENDING;
        }
    }

    case IOCTL_CDROM_GET_VOLUME: {

        DebugPrint((2, "CdRomDeviceControl: Get volume control\n"));

        //
        // Verify user buffer is large enough for data.
        //

        if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
            sizeof(VOLUME_CONTROL)) {

            //
            // Indicate unsuccessful status and no data transferred.
            //

            status = STATUS_BUFFER_TOO_SMALL;
            Irp->IoStatus.Information = 0;
            break;

        } else {
            IoMarkIrpPending(Irp);
            IoStartPacket(DeviceObject, Irp, NULL, NULL);

            return STATUS_PENDING;
        }
    }

    case IOCTL_CDROM_SET_VOLUME: {

        DebugPrint((2, "CdRomDeviceControl: Set volume control\n"));

        if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
            sizeof(VOLUME_CONTROL)) {

            //
            // Indicate unsuccessful status.
            //

            status = STATUS_BUFFER_TOO_SMALL;
            break;
        } else {

            IoMarkIrpPending(Irp);
            IoStartPacket(DeviceObject, Irp, NULL, NULL);

            return STATUS_PENDING;
        }
    }

    case IOCTL_CDROM_STOP_AUDIO: {

        //
        // Stop play.
        //

        DebugPrint((2, "CdRomDeviceControl: Stop audio\n"));

        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject,Irp, NULL,NULL);

        return STATUS_PENDING;
    }

    case IOCTL_CDROM_CHECK_VERIFY: {
        DebugPrint((1, "CdRomDeviceControl: [%lx] Check Verify\n", Irp));
        IoMarkIrpPending(Irp);

        if((irpStack->Parameters.DeviceIoControl.OutputBufferLength) &&
           (irpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG))) {

           DebugPrint((1, "CdRomDeviceControl: Check Verify: media count "
                          "buffer too small\n"));

           status = STATUS_BUFFER_TOO_SMALL;
           break;
        }

        IoStartPacket(DeviceObject,Irp, NULL,NULL);

        return STATUS_PENDING;
    }

    default: {

        //
        // allocate an event and stuff it into our stack location.
        //

        deviceControlEvent = ExAllocatePool(NonPagedPool, sizeof(KEVENT));

        if(!deviceControlEvent) {

            status = STATUS_INSUFFICIENT_RESOURCES;

        } else {

            PIO_STACK_LOCATION currentStack;

            KeInitializeEvent(deviceControlEvent, NotificationEvent, FALSE);

            currentStack = IoGetCurrentIrpStackLocation(Irp);
            nextStack = IoGetNextIrpStackLocation(Irp);

            //
            // Copy the stack down a notch
            //

            *nextStack = *currentStack;

            IoSetCompletionRoutine(
                Irp,
                CdRomClassIoctlCompletion,
                deviceControlEvent,
                TRUE,
                TRUE,
                TRUE
                );

            IoSetNextIrpStackLocation(Irp);

            Irp->IoStatus.Status = STATUS_SUCCESS;
            Irp->IoStatus.Information = 0;

            //
            // Override volume verifies on this stack location so that we
            // will be forced through the synchronization.  Once this location
            // goes away we get the old value back
            //

            nextStack->Flags |= SL_OVERRIDE_VERIFY_VOLUME;

            IoMarkIrpPending(Irp);

            IoStartPacket(DeviceObject, Irp, NULL, NULL);

            //
            // Wait for CdRomClassIoctlCompletion to set the event. This
            // ensures serialization remains intact for these unhandled device
            // controls.
            //

            KeWaitForSingleObject(
                deviceControlEvent,
                Suspended,
                KernelMode,
                FALSE,
                NULL);

            ExFreePool(deviceControlEvent);

            DebugPrint((2, "CdRomDeviceControl: irp %#08lx synchronized\n", Irp));

            //
            // If an error occured then propagate that back up - we are no longer
            // guaranteed synchronization and the upper layers will have to
            // retry.
            //
            // If no error occured, call down to the class driver directly
            // then start up the next request.
            //

            if(Irp->IoStatus.Status == STATUS_SUCCESS) {

                status = ScsiClassDeviceControl(DeviceObject, Irp);

                KeRaiseIrql(DISPATCH_LEVEL, &irql);

                IoStartNextPacket(DeviceObject, FALSE);

                KeLowerIrql(irql);
            }
        }

        return status;
    }

    } // end switch()

    if (status == STATUS_VERIFY_REQUIRED) {

        //
        // If the status is verified required and this request
        // should bypass verify required then retry the request.
        //

        if (irpStack->Flags & SL_OVERRIDE_VERIFY_VOLUME) {

            status = STATUS_IO_DEVICE_ERROR;
            goto RetryControl;

        }
    }

    if (IoIsErrorUserInduced(status)) {

        IoSetHardErrorOrVerifyDevice(Irp, DeviceObject);

    }

    //
    // Update IRP with completion status.
    //

    Irp->IoStatus.Status = status;

    //
    // Complete the request.
    //

    IoCompleteRequest(Irp, IO_DISK_INCREMENT);
    DebugPrint((2, "CdRomDeviceControl: Status is %lx\n", status));
    return status;

} // end ScsiCdRomDeviceControl()

Referenced by DriverEntry().

CdRomDeviceControlCompletion()

NTSTATUS NTAPI CdRomDeviceControlCompletion	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PVOID	Context
	)

Definition at line 2996 of file cdrom.c.

{
    PDEVICE_EXTENSION   deviceExtension = DeviceObject->DeviceExtension;
    PDEVICE_EXTENSION   physicalExtension = deviceExtension->PhysicalDevice->DeviceExtension;
    PIO_STACK_LOCATION  irpStack        = IoGetCurrentIrpStackLocation(Irp);
    PCDROM_DATA         cdData = (PCDROM_DATA)(deviceExtension + 1);
    BOOLEAN             use6Byte = cdData->XAFlags & XA_USE_6_BYTE;
    PIO_STACK_LOCATION  realIrpStack;
    PIO_STACK_LOCATION  realIrpNextStack;
    PSCSI_REQUEST_BLOCK srb     = Context;
    PIRP                realIrp = NULL;
    NTSTATUS            status;
    BOOLEAN             retry;

    //
    // Extract the 'real' irp from the irpstack.
    //

    realIrp = (PIRP) irpStack->Parameters.Others.Argument2;
    realIrpStack = IoGetCurrentIrpStackLocation(realIrp);
    realIrpNextStack = IoGetNextIrpStackLocation(realIrp);

    //
    // Check SRB status for success of completing request.
    //

    if (SRB_STATUS(srb->SrbStatus) != SRB_STATUS_SUCCESS) {

        DebugPrint((2,
                    "CdRomDeviceControlCompletion: Irp %lx, Srb %lx Real Irp %lx Status %lx\n",
                    Irp,
                    srb,
                    realIrp,
                    srb->SrbStatus));

        //
        // Release the queue if it is frozen.
        //

        if (srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN) {
            DebugPrint((2, "CdRomDeviceControlCompletion: Releasing Queue\n"));
            ScsiClassReleaseQueue(DeviceObject);
        }


        retry = ScsiClassInterpretSenseInfo(DeviceObject,
                                            srb,
                                            irpStack->MajorFunction,
                                            irpStack->Parameters.DeviceIoControl.IoControlCode,
                                            MAXIMUM_RETRIES - ((ULONG_PTR)realIrpNextStack->Parameters.Others.Argument1),
                                            &status);

        DebugPrint((2, "CdRomDeviceControlCompletion: IRP will %sbe retried\n",
                    (retry ? "" : "not ")));

        //
        // Some of the Device Controls need special cases on non-Success status's.
        //

        if (realIrpStack->MajorFunction == IRP_MJ_DEVICE_CONTROL) {
            if ((realIrpStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_CDROM_GET_LAST_SESSION) ||
                (realIrpStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_CDROM_READ_TOC)         ||
                (realIrpStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_CDROM_GET_CONTROL)      ||
                (realIrpStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_CDROM_GET_VOLUME)) {

                if (status == STATUS_DATA_OVERRUN) {
                    status = STATUS_SUCCESS;
                    retry = FALSE;
                }
            }

            if (realIrpStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_CDROM_READ_Q_CHANNEL) {
                PLAY_ACTIVE(deviceExtension) = FALSE;
            }
        }

        //
        // If the status is verified required and the this request
        // should bypass verify required then retry the request.
        //

        if (realIrpStack->Flags & SL_OVERRIDE_VERIFY_VOLUME &&
            status == STATUS_VERIFY_REQUIRED) {

            if (((realIrpStack->MajorFunction == IRP_MJ_DEVICE_CONTROL) ||
                (realIrpStack->MajorFunction == IRP_MJ_INTERNAL_DEVICE_CONTROL)) &&
                (realIrpStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_CDROM_CHECK_VERIFY)) {

                ExFreePool(srb->SenseInfoBuffer);
                if (srb->DataBuffer) {
                    ExFreePool(srb->DataBuffer);
                }
                ExFreePool(srb);
                if (Irp->MdlAddress) {
                    IoFreeMdl(Irp->MdlAddress);
                }

                IoFreeIrp(Irp);

                //
                // Update the geometry information, as the media could have changed.
                // The completion routine for this will complete the real irp and start
                // the next packet.
                //

                status = CdRomUpdateCapacity(deviceExtension,realIrp, NULL);
                DebugPrint((2, "CdRomDeviceControlCompletion: [%lx] CdRomUpdateCapacity completed with status %lx\n", realIrp, status));
                ASSERT(status == STATUS_PENDING);

                return STATUS_MORE_PROCESSING_REQUIRED;

            } else {

                status = STATUS_IO_DEVICE_ERROR;
                retry = TRUE;
            }

        }

        if (retry && (realIrpNextStack->Parameters.Others.Argument1 = (PVOID)((ULONG_PTR)realIrpNextStack->Parameters.Others.Argument1-1))) {


            if (((ULONG_PTR)realIrpNextStack->Parameters.Others.Argument1)) {

                //
                // Retry request.
                //

                DebugPrint((1, "Retry request %lx - Calling StartIo\n", Irp));


                ExFreePool(srb->SenseInfoBuffer);
                if (srb->DataBuffer) {
                    ExFreePool(srb->DataBuffer);
                }
                ExFreePool(srb);
                if (Irp->MdlAddress) {
                    IoFreeMdl(Irp->MdlAddress);
                }

                IoFreeIrp(Irp);

                //
                // Call StartIo directly since IoStartNextPacket hasn't been called,
                // the serialisation is still intact.
                //

                ScsiCdRomStartIo(DeviceObject, realIrp);
                return STATUS_MORE_PROCESSING_REQUIRED;

            }

            //
            // Exhausted retries. Fall through and complete the request with the appropriate status.
            //

        }
    } else {

        //
        // Set status for successful request.
        //

        status = STATUS_SUCCESS;
    }

    if (NT_SUCCESS(status)) {

        switch (realIrpStack->Parameters.DeviceIoControl.IoControlCode) {

        case IOCTL_DISK_GET_LENGTH_INFO: {

            PREAD_CAPACITY_DATA readCapacityBuffer = srb->DataBuffer;
            ULONG               lastSector;
            ULONG               bps;
            ULONG               lastBit;
            ULONG               tmp;

            //
            // Swizzle bytes from Read Capacity and translate into
            // the necessary geometry information in the device extension.
            //

            tmp = readCapacityBuffer->BytesPerBlock;
            ((PFOUR_BYTE)&bps)->Byte0 = ((PFOUR_BYTE)&tmp)->Byte3;
            ((PFOUR_BYTE)&bps)->Byte1 = ((PFOUR_BYTE)&tmp)->Byte2;
            ((PFOUR_BYTE)&bps)->Byte2 = ((PFOUR_BYTE)&tmp)->Byte1;
            ((PFOUR_BYTE)&bps)->Byte3 = ((PFOUR_BYTE)&tmp)->Byte0;

            //
            // Insure that bps is a power of 2.
            // This corrects a problem with the HP 4020i CDR where it
            // returns an incorrect number for bytes per sector.
            //

            if (!bps) {
                bps = 2048;
            } else {
                lastBit = (ULONG) -1;
                while (bps) {
                    lastBit++;
                    bps = bps >> 1;
                }

                bps = 1 << lastBit;
            }
            deviceExtension->DiskGeometry->Geometry.BytesPerSector = bps;

            DebugPrint((2,
                        "CdRomDeviceControlCompletion: Calculated bps %#x\n",
                        deviceExtension->DiskGeometry->Geometry.BytesPerSector));

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

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

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

            WHICH_BIT(bps, 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)/(32 * 64));

            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 32;
            //

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

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

            deviceExtension->DiskGeometry->Geometry.TracksPerCylinder = 64;

            //
            // Copy the device extension's geometry info into the user buffer.
            //

            RtlMoveMemory(realIrp->AssociatedIrp.SystemBuffer,
                          &deviceExtension->PartitionLength,
                          sizeof(GET_LENGTH_INFORMATION));

            //
            // update information field.
            //

            realIrp->IoStatus.Information = sizeof(GET_LENGTH_INFORMATION);
            break;
        }

        case IOCTL_DISK_GET_DRIVE_GEOMETRY_EX:
        case IOCTL_CDROM_GET_DRIVE_GEOMETRY_EX: {

            PREAD_CAPACITY_DATA readCapacityBuffer = srb->DataBuffer;
            ULONG               lastSector;
            ULONG               bps;
            ULONG               lastBit;
            ULONG               tmp;
            PDISK_GEOMETRY_EX   geometryEx;

            //
            // Swizzle bytes from Read Capacity and translate into
            // the necessary geometry information in the device extension.
            //

            tmp = readCapacityBuffer->BytesPerBlock;
            ((PFOUR_BYTE)&bps)->Byte0 = ((PFOUR_BYTE)&tmp)->Byte3;
            ((PFOUR_BYTE)&bps)->Byte1 = ((PFOUR_BYTE)&tmp)->Byte2;
            ((PFOUR_BYTE)&bps)->Byte2 = ((PFOUR_BYTE)&tmp)->Byte1;
            ((PFOUR_BYTE)&bps)->Byte3 = ((PFOUR_BYTE)&tmp)->Byte0;

            //
            // Insure that bps is a power of 2.
            // This corrects a problem with the HP 4020i CDR where it
            // returns an incorrect number for bytes per sector.
            //

            if (!bps) {
                bps = 2048;
            } else {
                lastBit = (ULONG) -1;
                while (bps) {
                    lastBit++;
                    bps = bps >> 1;
                }

                bps = 1 << lastBit;
            }
            deviceExtension->DiskGeometry->Geometry.BytesPerSector = bps;

            DebugPrint((2,
                        "CdRomDeviceControlCompletion: Calculated bps %#x\n",
                        deviceExtension->DiskGeometry->Geometry.BytesPerSector));

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

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

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

            WHICH_BIT(bps, 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)/(32 * 64));

            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 32;
            //

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

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

            deviceExtension->DiskGeometry->Geometry.TracksPerCylinder = 64;

            //
            // Copy the device extension's geometry info into the user buffer.
            //

            geometryEx = realIrp->AssociatedIrp.SystemBuffer;
            RtlMoveMemory(&geometryEx->Geometry,
                          &deviceExtension->DiskGeometry->Geometry,
                          sizeof(DISK_GEOMETRY));

            //
            // Copy the extended information
            //

            geometryEx->DiskSize = deviceExtension->PartitionLength;

            //
            // update information field.
            //

            realIrp->IoStatus.Information = FIELD_OFFSET(DISK_GEOMETRY_EX, Data);
            break;
        }

        case IOCTL_DISK_GET_DRIVE_GEOMETRY:
        case IOCTL_CDROM_GET_DRIVE_GEOMETRY: {

            PREAD_CAPACITY_DATA readCapacityBuffer = srb->DataBuffer;
            ULONG               lastSector;
            ULONG               bps;
            ULONG               lastBit;
            ULONG               tmp;

            //
            // Swizzle bytes from Read Capacity and translate into
            // the necessary geometry information in the device extension.
            //

            tmp = readCapacityBuffer->BytesPerBlock;
            ((PFOUR_BYTE)&bps)->Byte0 = ((PFOUR_BYTE)&tmp)->Byte3;
            ((PFOUR_BYTE)&bps)->Byte1 = ((PFOUR_BYTE)&tmp)->Byte2;
            ((PFOUR_BYTE)&bps)->Byte2 = ((PFOUR_BYTE)&tmp)->Byte1;
            ((PFOUR_BYTE)&bps)->Byte3 = ((PFOUR_BYTE)&tmp)->Byte0;

            //
            // Insure that bps is a power of 2.
            // This corrects a problem with the HP 4020i CDR where it
            // returns an incorrect number for bytes per sector.
            //

            if (!bps) {
                bps = 2048;
            } else {
                lastBit = (ULONG) -1;
                while (bps) {
                    lastBit++;
                    bps = bps >> 1;
                }

                bps = 1 << lastBit;
            }
            deviceExtension->DiskGeometry->Geometry.BytesPerSector = bps;

            DebugPrint((2,
                        "CdRomDeviceControlCompletion: Calculated bps %#x\n",
                        deviceExtension->DiskGeometry->Geometry.BytesPerSector));

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

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

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

            WHICH_BIT(bps, 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)/(32 * 64));

            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 32;
            //

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

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

            deviceExtension->DiskGeometry->Geometry.TracksPerCylinder = 64;

            //
            // Copy the device extension's geometry info into the user buffer.
            //

            RtlMoveMemory(realIrp->AssociatedIrp.SystemBuffer,
                          deviceExtension->DiskGeometry,
                          sizeof(DISK_GEOMETRY));

            //
            // update information field.
            //

            realIrp->IoStatus.Information = sizeof(DISK_GEOMETRY);
            break;
        }

        case IOCTL_CDROM_CHECK_VERIFY:

            if((realIrpStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_CDROM_CHECK_VERIFY) &&
               (realIrpStack->Parameters.DeviceIoControl.OutputBufferLength)) {

                *((PULONG)realIrp->AssociatedIrp.SystemBuffer) =
                    physicalExtension->MediaChangeCount;
                realIrp->IoStatus.Information = sizeof(ULONG);
            } else {
                realIrp->IoStatus.Information = 0;
            }

            DebugPrint((2, "CdRomDeviceControlCompletion: [%lx] completing CHECK_VERIFY buddy irp %lx\n", realIrp, Irp));
            break;

        case IOCTL_CDROM_GET_LAST_SESSION:
        case IOCTL_CDROM_READ_TOC: {

                PCDROM_TOC toc = srb->DataBuffer;

                //
                // Copy the device extension's geometry info into the user buffer.
                //

                RtlMoveMemory(realIrp->AssociatedIrp.SystemBuffer,
                              toc,
                              srb->DataTransferLength);

                //
                // update information field.
                //

                realIrp->IoStatus.Information = srb->DataTransferLength;
                break;
            }

        case IOCTL_CDROM_PLAY_AUDIO_MSF:

            PLAY_ACTIVE(deviceExtension) = TRUE;

            break;

        case IOCTL_CDROM_READ_Q_CHANNEL: {

            PSUB_Q_CHANNEL_DATA userChannelData = realIrp->AssociatedIrp.SystemBuffer;
#if DBG
            PCDROM_SUB_Q_DATA_FORMAT inputBuffer = realIrp->AssociatedIrp.SystemBuffer;
#endif
            PSUB_Q_CHANNEL_DATA subQPtr = srb->DataBuffer;

#if DBG
            switch( inputBuffer->Format ) {

            case IOCTL_CDROM_CURRENT_POSITION:
                DebugPrint((2,"CdRomDeviceControlCompletion: Audio Status is %u\n", subQPtr->CurrentPosition.Header.AudioStatus ));
                DebugPrint((2,"CdRomDeviceControlCompletion: ADR = 0x%x\n", subQPtr->CurrentPosition.ADR ));
                DebugPrint((2,"CdRomDeviceControlCompletion: Control = 0x%x\n", subQPtr->CurrentPosition.Control ));
                DebugPrint((2,"CdRomDeviceControlCompletion: Track = %u\n", subQPtr->CurrentPosition.TrackNumber ));
                DebugPrint((2,"CdRomDeviceControlCompletion: Index = %u\n", subQPtr->CurrentPosition.IndexNumber ));
                DebugPrint((2,"CdRomDeviceControlCompletion: Absolute Address = %x\n", *((PULONG)subQPtr->CurrentPosition.AbsoluteAddress) ));
                DebugPrint((2,"CdRomDeviceControlCompletion: Relative Address = %x\n", *((PULONG)subQPtr->CurrentPosition.TrackRelativeAddress) ));
                break;

            case IOCTL_CDROM_MEDIA_CATALOG:
                DebugPrint((2,"CdRomDeviceControlCompletion: Audio Status is %u\n", subQPtr->MediaCatalog.Header.AudioStatus ));
                DebugPrint((2,"CdRomDeviceControlCompletion: Mcval is %u\n", subQPtr->MediaCatalog.Mcval ));
                break;

            case IOCTL_CDROM_TRACK_ISRC:
                DebugPrint((2,"CdRomDeviceControlCompletion: Audio Status is %u\n", subQPtr->TrackIsrc.Header.AudioStatus ));
                DebugPrint((2,"CdRomDeviceControlCompletion: Tcval is %u\n", subQPtr->TrackIsrc.Tcval ));
                break;

            }
#endif

            //
            // Update the play active status.
            //

            if (subQPtr->CurrentPosition.Header.AudioStatus == AUDIO_STATUS_IN_PROGRESS) {

                PLAY_ACTIVE(deviceExtension) = TRUE;

            } else {

                PLAY_ACTIVE(deviceExtension) = FALSE;

            }

            //
            // Check if output buffer is large enough to contain
            // the data.
            //

            if (realIrpStack->Parameters.DeviceIoControl.OutputBufferLength <
                srb->DataTransferLength) {

                srb->DataTransferLength =
                    realIrpStack->Parameters.DeviceIoControl.OutputBufferLength;
            }

            //
            // Copy our buffer into users.
            //

            RtlMoveMemory(userChannelData,
                          subQPtr,
                          srb->DataTransferLength);

            realIrp->IoStatus.Information = srb->DataTransferLength;
            break;
        }

        case IOCTL_CDROM_PAUSE_AUDIO:

            PLAY_ACTIVE(deviceExtension) = FALSE;
            realIrp->IoStatus.Information = 0;
            break;

        case IOCTL_CDROM_RESUME_AUDIO:

            realIrp->IoStatus.Information = 0;
            break;

        case IOCTL_CDROM_SEEK_AUDIO_MSF:

            realIrp->IoStatus.Information = 0;
            break;

        case IOCTL_CDROM_STOP_AUDIO:

            PLAY_ACTIVE(deviceExtension) = FALSE;

            realIrp->IoStatus.Information = 0;
            break;

        case IOCTL_CDROM_GET_CONTROL: {

            PCDROM_AUDIO_CONTROL audioControl = srb->DataBuffer;
            PAUDIO_OUTPUT        audioOutput;
            ULONG                bytesTransferred;

            audioOutput = ScsiClassFindModePage((PCHAR)audioControl,
                                                srb->DataTransferLength,
                                                CDROM_AUDIO_CONTROL_PAGE,
                                                use6Byte);
            //
            // Verify the page is as big as expected.
            //

            bytesTransferred = (PCHAR) audioOutput - (PCHAR) audioControl +
                               sizeof(AUDIO_OUTPUT);

            if (audioOutput != NULL &&
                srb->DataTransferLength >= bytesTransferred) {

                audioControl->LbaFormat = audioOutput->LbaFormat;

                audioControl->LogicalBlocksPerSecond =
                    (audioOutput->LogicalBlocksPerSecond[0] << (UCHAR)8) |
                    audioOutput->LogicalBlocksPerSecond[1];

                realIrp->IoStatus.Information = sizeof(CDROM_AUDIO_CONTROL);

            } else {
                realIrp->IoStatus.Information = 0;
                status = STATUS_INVALID_DEVICE_REQUEST;
            }
            break;
        }

        case IOCTL_CDROM_GET_VOLUME: {

            PAUDIO_OUTPUT audioOutput;
            PVOLUME_CONTROL volumeControl = srb->DataBuffer;
            ULONG i,bytesTransferred;

            audioOutput = ScsiClassFindModePage((PCHAR)volumeControl,
                                                 srb->DataTransferLength,
                                                 CDROM_AUDIO_CONTROL_PAGE,
                                                 use6Byte);

            //
            // Verify the page is as big as expected.
            //

            bytesTransferred = (PCHAR) audioOutput - (PCHAR) volumeControl +
                               sizeof(AUDIO_OUTPUT);

            if (audioOutput != NULL &&
                srb->DataTransferLength >= bytesTransferred) {

                for (i=0; i<4; i++) {
                    volumeControl->PortVolume[i] =
                        audioOutput->PortOutput[i].Volume;
                }

                //
                // Set bytes transferred in IRP.
                //

                realIrp->IoStatus.Information = sizeof(VOLUME_CONTROL);

            } else {
                realIrp->IoStatus.Information = 0;
                status = STATUS_INVALID_DEVICE_REQUEST;
            }

            break;
        }

        case IOCTL_CDROM_SET_VOLUME:

            realIrp->IoStatus.Information = sizeof(VOLUME_CONTROL);
            break;

        default:

            ASSERT(FALSE);
            realIrp->IoStatus.Information = 0;
            status = STATUS_INVALID_DEVICE_REQUEST;

        } // end switch()
    }

    //
    // Deallocate srb and sense buffer.
    //

    if (srb) {
        if (srb->DataBuffer) {
            ExFreePool(srb->DataBuffer);
        }
        if (srb->SenseInfoBuffer) {
            ExFreePool(srb->SenseInfoBuffer);
        }
        ExFreePool(srb);
    }

    if (realIrp->PendingReturned) {
        IoMarkIrpPending(realIrp);
    }

    if (Irp->MdlAddress) {
        IoFreeMdl(Irp->MdlAddress);
    }

    IoFreeIrp(Irp);

    //
    // Set status in completing IRP.
    //

    realIrp->IoStatus.Status = status;

    //
    // Set the hard error if necessary.
    //

    if (!NT_SUCCESS(status) && IoIsErrorUserInduced(status)) {

        //
        // Store DeviceObject for filesystem, and clear
        // in IoStatus.Information field.
        //

        DebugPrint((1, "CdRomDeviceCompletion - Setting Hard Error on realIrp %lx\n",
                    realIrp));
        IoSetHardErrorOrVerifyDevice(realIrp, DeviceObject);
        realIrp->IoStatus.Information = 0;
    }

    IoCompleteRequest(realIrp, IO_DISK_INCREMENT);

    IoStartNextPacket(DeviceObject, FALSE);

    return STATUS_MORE_PROCESSING_REQUIRED;
}

CdRomIsPlayActive()

BOOLEAN NTAPI CdRomIsPlayActive

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 5869 of file cdrom.c.

{
    PDEVICE_EXTENSION  deviceExtension = DeviceObject->DeviceExtension;
    PIRP irp;
    IO_STATUS_BLOCK ioStatus;
    KEVENT event;
    NTSTATUS status;
    PSUB_Q_CURRENT_POSITION currentBuffer;

    if (!PLAY_ACTIVE(deviceExtension)) {
        return(FALSE);
    }

    currentBuffer = ExAllocatePool(NonPagedPoolCacheAligned, sizeof(SUB_Q_CURRENT_POSITION));

    if (currentBuffer == NULL) {
        return(FALSE);
    }

    ((PCDROM_SUB_Q_DATA_FORMAT) currentBuffer)->Format = IOCTL_CDROM_CURRENT_POSITION;
    ((PCDROM_SUB_Q_DATA_FORMAT) currentBuffer)->Track = 0;

    //
    // 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_CDROM_READ_Q_CHANNEL,
                                        deviceExtension->DeviceObject,
                                        currentBuffer,
                                        sizeof(CDROM_SUB_Q_DATA_FORMAT),
                                        currentBuffer,
                                        sizeof(SUB_Q_CURRENT_POSITION),
                                        FALSE,
                                        &event,
                                        &ioStatus);

    if (irp == NULL) {
        ExFreePool(currentBuffer);
        return FALSE;
    }

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

    status = IoCallDriver(deviceExtension->DeviceObject, irp);

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

    if (!NT_SUCCESS(status)) {
        ExFreePool(currentBuffer);
        return FALSE;
    }

    ExFreePool(currentBuffer);

    return(PLAY_ACTIVE(deviceExtension));

}

Referenced by CdRomDeviceControl(), and CdRomDeviceControlDispatch().

CdRomMediaChangeCompletion()

NTSTATUS NTAPI CdRomMediaChangeCompletion	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PVOID	Context
	)

Definition at line 5961 of file cdrom.c.

{
    PSCSI_REQUEST_BLOCK srb = (PSCSI_REQUEST_BLOCK) Context;
    PIO_STACK_LOCATION  cdStack = IoGetCurrentIrpStackLocation(Irp);
    PIO_STACK_LOCATION  irpNextStack = IoGetNextIrpStackLocation(Irp);
    PDEVICE_EXTENSION   deviceExtension;
    PDEVICE_EXTENSION   physicalExtension;
    PSENSE_DATA         senseBuffer;
    PCDROM_DATA         cddata;

    ASSERT(Irp);
    ASSERT(cdStack);
    DeviceObject = cdStack->DeviceObject;
    ASSERT(DeviceObject);

    deviceExtension = DeviceObject->DeviceExtension;
    physicalExtension = deviceExtension->PhysicalDevice->DeviceExtension;
    cddata = (PCDROM_DATA)(deviceExtension + 1);

    ASSERT(cddata->MediaChangeIrp == NULL);

    //
    // If the sense data field is valid, look for a media change.
    // otherwise this iteration of the polling will just assume nothing
    // changed.
    //

    DebugPrint((3, "CdRomMediaChangeHandler: Completing Autorun Irp 0x%lx "
                   "for device %d\n",
                   Irp, deviceExtension->DeviceNumber));

    if (srb->SrbStatus & SRB_STATUS_AUTOSENSE_VALID) {
        if (srb->SenseInfoBufferLength >= FIELD_OFFSET(SENSE_DATA, CommandSpecificInformation)) {

            //
            // See if this is a media change.
            //

            senseBuffer = srb->SenseInfoBuffer;
            if ((senseBuffer->SenseKey & 0x0f) == SCSI_SENSE_UNIT_ATTENTION)  {
                if (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_MEDIUM_CHANGED) {

                    DebugPrint((1, "CdRomMediaChangeCompletion: New media inserted "
                                   "into CdRom%d [irp = 0x%lx]\n",
                                deviceExtension->DeviceNumber, Irp));

                    //
                    // Media change event occurred - signal the named event.
                    //

                    KeSetEvent(deviceExtension->MediaChangeEvent,
                               (KPRIORITY) 0,
                               FALSE);

                    deviceExtension->MediaChangeNoMedia = FALSE;

                }

                if (DeviceObject->Vpb->Flags & VPB_MOUNTED) {

                    //
                    // Must remember the media changed and force the
                    // file system to verify on next access
                    //

                    DeviceObject->Flags |= DO_VERIFY_VOLUME;
                }

                physicalExtension->MediaChangeCount++;

            } else if(((senseBuffer->SenseKey & 0x0f) == SCSI_SENSE_NOT_READY)&&
                      (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_NO_MEDIA_IN_DEVICE)&&
                      (!deviceExtension->MediaChangeNoMedia)){

                //
                // If there was no media in the device then signal the waiters if
                // we haven't already done so before.
                //

                DebugPrint((1, "CdRomMediaChangeCompletion: No media in device"
                               "CdRom%d [irp = 0x%lx]\n",
                            deviceExtension->DeviceNumber, Irp));

                KeSetEvent(deviceExtension->MediaChangeEvent,
                           (KPRIORITY) 0,
                           FALSE);

                deviceExtension->MediaChangeNoMedia = TRUE;

            }
        }
    } else if((srb->SrbStatus == SRB_STATUS_SUCCESS)&&
              (deviceExtension->MediaChangeNoMedia)) {
        //
        // We didn't have any media before and now the requests are succeeding
        // we probably missed the Media change somehow.  Signal the change
        // anyway
        //

        DebugPrint((1, "CdRomMediaChangeCompletion: Request completed normally"
                       "for CdRom%d which was marked w/NoMedia [irp = 0x%lx]\n",
                    deviceExtension->DeviceNumber, Irp));

        KeSetEvent(deviceExtension->MediaChangeEvent,
                   (KPRIORITY) 0,
                   FALSE);

        deviceExtension->MediaChangeNoMedia = FALSE;

    }

    if (srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN) {
        ScsiClassReleaseQueue(deviceExtension->DeviceObject);
    }

    //
    // Remember the IRP and SRB for use the next time.
    //

    irpNextStack->Parameters.Scsi.Srb = srb;
    cddata->MediaChangeIrp = Irp;

    if (deviceExtension->ClassError) {

        NTSTATUS status;
        BOOLEAN  retry;

        //
        // Throw away the status and retry values. Just give the error routine a chance
        // to do what it needs to.
        //

        deviceExtension->ClassError(DeviceObject,
                                    srb,
                                    &status,
                                    &retry);
    }

    IoStartNextPacket(DeviceObject, FALSE);

    return STATUS_MORE_PROCESSING_REQUIRED;
}

CdRomSetVolumeIntermediateCompletion()

NTSTATUS NTAPI CdRomSetVolumeIntermediateCompletion	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PVOID	Context
	)

Definition at line 3834 of file cdrom.c.

{
    PDEVICE_EXTENSION   deviceExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION  irpStack        = IoGetCurrentIrpStackLocation(Irp);
    PCDROM_DATA         cdData = (PCDROM_DATA)(deviceExtension + 1);
    BOOLEAN             use6Byte = cdData->XAFlags & XA_USE_6_BYTE;
    PIO_STACK_LOCATION  realIrpStack;
    PIO_STACK_LOCATION  realIrpNextStack;
    PSCSI_REQUEST_BLOCK srb     = Context;
    PIRP                realIrp = NULL;
    NTSTATUS            status;
    BOOLEAN             retry;

    //
    // Extract the 'real' irp from the irpstack.
    //

    realIrp = (PIRP) irpStack->Parameters.Others.Argument2;
    realIrpStack = IoGetCurrentIrpStackLocation(realIrp);
    realIrpNextStack = IoGetNextIrpStackLocation(realIrp);

    //
    // Check SRB status for success of completing request.
    //

    if (SRB_STATUS(srb->SrbStatus) != SRB_STATUS_SUCCESS) {

        DebugPrint((2,
                    "CdRomSetVolumeIntermediateCompletion: Irp %lx, Srb %lx Real Irp\n",
                    Irp,
                    srb,
                    realIrp));

        //
        // Release the queue if it is frozen.
        //

        if (srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN) {
            ScsiClassReleaseQueue(DeviceObject);
        }


        retry = ScsiClassInterpretSenseInfo(DeviceObject,
                                            srb,
                                            irpStack->MajorFunction,
                                            irpStack->Parameters.DeviceIoControl.IoControlCode,
                                            MAXIMUM_RETRIES - ((ULONG_PTR)realIrpNextStack->Parameters.Others.Argument1),
                                            &status);

        if (status == STATUS_DATA_OVERRUN) {
            status = STATUS_SUCCESS;
            retry = FALSE;
        }

        //
        // If the status is verified required and the this request
        // should bypass verify required then retry the request.
        //

        if (realIrpStack->Flags & SL_OVERRIDE_VERIFY_VOLUME &&
            status == STATUS_VERIFY_REQUIRED) {

            status = STATUS_IO_DEVICE_ERROR;
            retry = TRUE;
        }

        if (retry && (realIrpNextStack->Parameters.Others.Argument1 = (PVOID)((ULONG_PTR)realIrpNextStack->Parameters.Others.Argument1-1))) {

            if (((ULONG_PTR)realIrpNextStack->Parameters.Others.Argument1)) {

                //
                // Retry request.
                //

                DebugPrint((1, "Retry request %lx - Calling StartIo\n", Irp));


                ExFreePool(srb->SenseInfoBuffer);
                ExFreePool(srb->DataBuffer);
                ExFreePool(srb);
                if (Irp->MdlAddress) {
                    IoFreeMdl(Irp->MdlAddress);
                }

                IoFreeIrp(Irp);

                //
                // Call StartIo directly since IoStartNextPacket hasn't been called,
                // the serialisation is still intact.
                //
                ScsiCdRomStartIo(DeviceObject, realIrp);
                return STATUS_MORE_PROCESSING_REQUIRED;

            }

            //
            // Exhausted retries. Fall through and complete the request with the appropriate status.
            //

        }
    } else {

        //
        // Set status for successful request.
        //

        status = STATUS_SUCCESS;
    }

    if (NT_SUCCESS(status)) {

        PAUDIO_OUTPUT   audioInput = NULL;
        PAUDIO_OUTPUT   audioOutput;
        PVOLUME_CONTROL volumeControl = realIrp->AssociatedIrp.SystemBuffer;
        ULONG           i,bytesTransferred,headerLength;
        PVOID           dataBuffer;
        PCDB            cdb;

        audioInput = ScsiClassFindModePage((PCHAR)srb->DataBuffer,
                                             srb->DataTransferLength,
                                             CDROM_AUDIO_CONTROL_PAGE,
                                             use6Byte);

        //
        // Check to make sure the mode sense data is valid before we go on
        //

        if(audioInput == NULL) {

            DebugPrint((1, "Mode Sense Page %d not found\n",
                        CDROM_AUDIO_CONTROL_PAGE));

            realIrp->IoStatus.Information = 0;
            realIrp->IoStatus.Status = STATUS_IO_DEVICE_ERROR;
            IoCompleteRequest(realIrp, IO_DISK_INCREMENT);
            ExFreePool(srb->SenseInfoBuffer);
            ExFreePool(srb);
            IoFreeMdl(Irp->MdlAddress);
            IoFreeIrp(Irp);
            return STATUS_MORE_PROCESSING_REQUIRED;
        }

        if (use6Byte) {
            headerLength = sizeof(MODE_PARAMETER_HEADER);
        } else {
            headerLength = sizeof(MODE_PARAMETER_HEADER10);
        }

        bytesTransferred = sizeof(AUDIO_OUTPUT) + headerLength;

        //
        // Allocate a new buffer for the mode select.
        //

        dataBuffer = ExAllocatePool(NonPagedPoolCacheAligned, bytesTransferred);

        if (!dataBuffer) {
            realIrp->IoStatus.Information = 0;
            realIrp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
            IoCompleteRequest(realIrp, IO_DISK_INCREMENT);
            ExFreePool(srb->SenseInfoBuffer);
            ExFreePool(srb);
            IoFreeMdl(Irp->MdlAddress);
            IoFreeIrp(Irp);
            return STATUS_MORE_PROCESSING_REQUIRED;
        }

        RtlZeroMemory(dataBuffer, bytesTransferred);

        //
        // Rebuild the data buffer to include the user requested values.
        //

        audioOutput = (PAUDIO_OUTPUT) ((PCHAR) dataBuffer + headerLength);

        for (i=0; i<4; i++) {
            audioOutput->PortOutput[i].Volume =
                volumeControl->PortVolume[i];
            audioOutput->PortOutput[i].ChannelSelection =
                audioInput->PortOutput[i].ChannelSelection;
        }

        audioOutput->CodePage = CDROM_AUDIO_CONTROL_PAGE;
        audioOutput->ParameterLength = sizeof(AUDIO_OUTPUT) - 2;
        audioOutput->Immediate = MODE_SELECT_IMMEDIATE;

        //
        // Free the old data buffer, mdl.
        //

        ExFreePool(srb->DataBuffer);
        IoFreeMdl(Irp->MdlAddress);

        //
        // rebuild the srb.
        //

        cdb = (PCDB)srb->Cdb;
        RtlZeroMemory(cdb, CDB12GENERIC_LENGTH);

        srb->SrbStatus = srb->ScsiStatus = 0;
        srb->SrbFlags = deviceExtension->SrbFlags;
        srb->SrbFlags |= (SRB_FLAGS_DISABLE_SYNCH_TRANSFER | SRB_FLAGS_DATA_OUT);
        srb->DataTransferLength = bytesTransferred;

        if (use6Byte) {

            cdb->MODE_SELECT.OperationCode = SCSIOP_MODE_SELECT;
            cdb->MODE_SELECT.ParameterListLength = (UCHAR) bytesTransferred;
            cdb->MODE_SELECT.PFBit = 1;
            srb->CdbLength = 6;
        } else {

            cdb->MODE_SELECT10.OperationCode = SCSIOP_MODE_SELECT10;
            cdb->MODE_SELECT10.ParameterListLength[0] = (UCHAR) (bytesTransferred >> 8);
            cdb->MODE_SELECT10.ParameterListLength[1] = (UCHAR) (bytesTransferred & 0xFF);
            cdb->MODE_SELECT10.PFBit = 1;
            srb->CdbLength = 10;
        }

        //
        // Prepare the MDL
        //

        Irp->MdlAddress = IoAllocateMdl(dataBuffer,
                                        bytesTransferred,
                                        FALSE,
                                        FALSE,
                                        (PIRP) NULL);

        if (!Irp->MdlAddress) {
            realIrp->IoStatus.Information = 0;
            realIrp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
            IoCompleteRequest(realIrp, IO_DISK_INCREMENT);
            ExFreePool(srb->SenseInfoBuffer);
            ExFreePool(srb);
            ExFreePool(dataBuffer);
            IoFreeIrp(Irp);
            return STATUS_MORE_PROCESSING_REQUIRED;

        }

        MmBuildMdlForNonPagedPool(Irp->MdlAddress);
        srb->DataBuffer = dataBuffer;

        irpStack = IoGetNextIrpStackLocation(Irp);
        irpStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
        irpStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_SCSI_EXECUTE_IN;
        irpStack->Parameters.Scsi.Srb = srb;

        //
        // reset the irp completion.
        //

        IoSetCompletionRoutine(Irp,
                               CdRomDeviceControlCompletion,
                               srb,
                               TRUE,
                               TRUE,
                               TRUE);
        //
        // Call the port driver.
        //

        IoCallDriver(deviceExtension->PortDeviceObject, Irp);

        return STATUS_MORE_PROCESSING_REQUIRED;
    }

    //
    // Deallocate srb and sense buffer.
    //

    if (srb) {
        if (srb->DataBuffer) {
            ExFreePool(srb->DataBuffer);
        }
        if (srb->SenseInfoBuffer) {
            ExFreePool(srb->SenseInfoBuffer);
        }
        ExFreePool(srb);
    }

    if (Irp->PendingReturned) {
      IoMarkIrpPending(Irp);
    }

    if (realIrp->PendingReturned) {
        IoMarkIrpPending(realIrp);
    }

    if (Irp->MdlAddress) {
        IoFreeMdl(Irp->MdlAddress);
    }

    IoFreeIrp(Irp);

    //
    // Set status in completing IRP.
    //

    realIrp->IoStatus.Status = status;

    //
    // Set the hard error if necessary.
    //

    if (!NT_SUCCESS(status) && IoIsErrorUserInduced(status)) {

        //
        // Store DeviceObject for filesystem, and clear
        // in IoStatus.Information field.
        //

        IoSetHardErrorOrVerifyDevice(realIrp, DeviceObject);
        realIrp->IoStatus.Information = 0;
    }

    IoCompleteRequest(realIrp, IO_DISK_INCREMENT);

    IoStartNextPacket(DeviceObject, FALSE);

    return STATUS_MORE_PROCESSING_REQUIRED;
}

CdRomSwitchModeCompletion()

NTSTATUS NTAPI CdRomSwitchModeCompletion	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PVOID	Context
	)

Definition at line 4166 of file cdrom.c.

{
    PDEVICE_EXTENSION   deviceExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION  irpStack        = IoGetCurrentIrpStackLocation(Irp);
    PCDROM_DATA         cdData = (PCDROM_DATA)(deviceExtension + 1);
    PIO_STACK_LOCATION  realIrpStack;
    PIO_STACK_LOCATION  realIrpNextStack;
    PSCSI_REQUEST_BLOCK srb     = Context;
    PIRP                realIrp = NULL;
    NTSTATUS            status;
    BOOLEAN             retry;

    //
    // Extract the 'real' irp from the irpstack.
    //

    realIrp = (PIRP) irpStack->Parameters.Others.Argument2;
    realIrpStack = IoGetCurrentIrpStackLocation(realIrp);
    realIrpNextStack = IoGetNextIrpStackLocation(realIrp);

    //
    // Check SRB status for success of completing request.
    //

    if (SRB_STATUS(srb->SrbStatus) != SRB_STATUS_SUCCESS) {

        DebugPrint((2,
                    "CdRomSetVolumeIntermediateCompletion: Irp %lx, Srb %lx Real Irp\n",
                    Irp,
                    srb,
                    realIrp));

        //
        // Release the queue if it is frozen.
        //

        if (srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN) {
            ScsiClassReleaseQueue(DeviceObject);
        }


        retry = ScsiClassInterpretSenseInfo(DeviceObject,
                                            srb,
                                            irpStack->MajorFunction,
                                            irpStack->Parameters.DeviceIoControl.IoControlCode,
                                            MAXIMUM_RETRIES - ((ULONG_PTR)realIrpNextStack->Parameters.Others.Argument1),
                                            &status);

        //
        // If the status is verified required and the this request
        // should bypass verify required then retry the request.
        //

        if (realIrpStack->Flags & SL_OVERRIDE_VERIFY_VOLUME &&
            status == STATUS_VERIFY_REQUIRED) {

            status = STATUS_IO_DEVICE_ERROR;
            retry = TRUE;
        }

        if (retry && (realIrpNextStack->Parameters.Others.Argument1 = (PVOID)((ULONG_PTR)realIrpNextStack->Parameters.Others.Argument1-1))) {

            if (((ULONG_PTR)realIrpNextStack->Parameters.Others.Argument1)) {

                //
                // Retry request.
                //

                DebugPrint((1, "Retry request %lx - Calling StartIo\n", Irp));


                ExFreePool(srb->SenseInfoBuffer);
                ExFreePool(srb->DataBuffer);
                ExFreePool(srb);
                if (Irp->MdlAddress) {
                    IoFreeMdl(Irp->MdlAddress);
                }

                IoFreeIrp(Irp);

                //
                // Call StartIo directly since IoStartNextPacket hasn't been called,
                // the serialisation is still intact.
                //

                ScsiCdRomStartIo(DeviceObject, realIrp);
                return STATUS_MORE_PROCESSING_REQUIRED;

            }

            //
            // Exhausted retries. Fall through and complete the request with the appropriate status.
            //
        }
    } else {

        //
        // Set status for successful request.
        //

        status = STATUS_SUCCESS;
    }

    if (NT_SUCCESS(status)) {

        ULONG sectorSize, startingSector, transferByteCount;
        PCDB cdb;

        //
        // Update device ext. to show which mode we are currently using.
        //

        sectorSize =  cdData->u1.BlockDescriptor.BlockLength[0] << 16;
        sectorSize |= (cdData->u1.BlockDescriptor.BlockLength[1] << 8);
        sectorSize |= (cdData->u1.BlockDescriptor.BlockLength[2]);

        cdData->RawAccess = (sectorSize == RAW_SECTOR_SIZE) ? TRUE : FALSE;

        //
        // Free the old data buffer, mdl.
        //

        ExFreePool(srb->DataBuffer);
        IoFreeMdl(Irp->MdlAddress);
        IoFreeIrp(Irp);

        //
        // rebuild the srb.
        //

        cdb = (PCDB)srb->Cdb;
        RtlZeroMemory(cdb, CDB12GENERIC_LENGTH);


        if (cdData->RawAccess) {

            PRAW_READ_INFO rawReadInfo =
                               (PRAW_READ_INFO)realIrpStack->Parameters.DeviceIoControl.Type3InputBuffer;

            ULONG maximumTransferLength;
            ULONG transferPages;

            //
            // Calculate starting offset.
            //

            startingSector = (ULONG)(rawReadInfo->DiskOffset.QuadPart >> deviceExtension->SectorShift);
            transferByteCount  = rawReadInfo->SectorCount * RAW_SECTOR_SIZE;
            maximumTransferLength = deviceExtension->PortCapabilities->MaximumTransferLength;
            transferPages = ADDRESS_AND_SIZE_TO_SPAN_PAGES(MmGetMdlVirtualAddress(realIrp->MdlAddress),
                                                           transferByteCount);

            //
            // Determine if request is within limits imposed by miniport.
            // If the request is larger than the miniport's capabilities, split it.
            //

            if (transferByteCount > maximumTransferLength ||
                transferPages > deviceExtension->PortCapabilities->MaximumPhysicalPages) {

                realIrp->IoStatus.Information = 0;
                realIrp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                IoCompleteRequest(realIrp, IO_DISK_INCREMENT);

                ExFreePool(srb->SenseInfoBuffer);
                ExFreePool(srb);

                IoStartNextPacket(DeviceObject, FALSE);

                return STATUS_MORE_PROCESSING_REQUIRED;
            }

            srb->OriginalRequest = realIrp;
            srb->SrbFlags = deviceExtension->SrbFlags;
            srb->SrbFlags |= (SRB_FLAGS_DISABLE_SYNCH_TRANSFER | SRB_FLAGS_DATA_IN);
            srb->DataTransferLength = transferByteCount;
            srb->TimeOutValue = deviceExtension->TimeOutValue;
            srb->CdbLength = 10;
            srb->DataBuffer = MmGetMdlVirtualAddress(realIrp->MdlAddress);

            if (rawReadInfo->TrackMode == CDDA) {
                if (cdData->XAFlags & PLEXTOR_CDDA) {

                    srb->CdbLength = 12;

                    cdb->PLXTR_READ_CDDA.LogicalUnitNumber = deviceExtension->Lun;
                    cdb->PLXTR_READ_CDDA.LogicalBlockByte3  = (UCHAR) (startingSector & 0xFF);
                    cdb->PLXTR_READ_CDDA.LogicalBlockByte2  = (UCHAR) ((startingSector >>  8) & 0xFF);
                    cdb->PLXTR_READ_CDDA.LogicalBlockByte1  = (UCHAR) ((startingSector >> 16) & 0xFF);
                    cdb->PLXTR_READ_CDDA.LogicalBlockByte0  = (UCHAR) ((startingSector >> 24) & 0xFF);

                    cdb->PLXTR_READ_CDDA.TransferBlockByte3 = (UCHAR) (rawReadInfo->SectorCount & 0xFF);
                    cdb->PLXTR_READ_CDDA.TransferBlockByte2 = (UCHAR) (rawReadInfo->SectorCount >> 8);
                    cdb->PLXTR_READ_CDDA.TransferBlockByte1 = 0;
                    cdb->PLXTR_READ_CDDA.TransferBlockByte0 = 0;

                    cdb->PLXTR_READ_CDDA.SubCode = 0;
                    cdb->PLXTR_READ_CDDA.OperationCode = 0xD8;

                } else if (cdData->XAFlags & NEC_CDDA) {

                    cdb->NEC_READ_CDDA.LogicalBlockByte3  = (UCHAR) (startingSector & 0xFF);
                    cdb->NEC_READ_CDDA.LogicalBlockByte2  = (UCHAR) ((startingSector >>  8) & 0xFF);
                    cdb->NEC_READ_CDDA.LogicalBlockByte1  = (UCHAR) ((startingSector >> 16) & 0xFF);
                    cdb->NEC_READ_CDDA.LogicalBlockByte0  = (UCHAR) ((startingSector >> 24) & 0xFF);

                    cdb->NEC_READ_CDDA.TransferBlockByte1 = (UCHAR) (rawReadInfo->SectorCount & 0xFF);
                    cdb->NEC_READ_CDDA.TransferBlockByte0 = (UCHAR) (rawReadInfo->SectorCount >> 8);

                    cdb->NEC_READ_CDDA.OperationCode = 0xD4;
                }
            } else {
                cdb->CDB10.LogicalUnitNumber = deviceExtension->Lun;

                cdb->CDB10.TransferBlocksMsb  = (UCHAR) (rawReadInfo->SectorCount >> 8);
                cdb->CDB10.TransferBlocksLsb  = (UCHAR) (rawReadInfo->SectorCount & 0xFF);

                cdb->CDB10.LogicalBlockByte3  = (UCHAR) (startingSector & 0xFF);
                cdb->CDB10.LogicalBlockByte2  = (UCHAR) ((startingSector >>  8) & 0xFF);
                cdb->CDB10.LogicalBlockByte1  = (UCHAR) ((startingSector >> 16) & 0xFF);
                cdb->CDB10.LogicalBlockByte0  = (UCHAR) ((startingSector >> 24) & 0xFF);

                cdb->CDB10.OperationCode = SCSIOP_READ;
            }

            srb->SrbStatus = srb->ScsiStatus = 0;


            irpStack = IoGetNextIrpStackLocation(realIrp);
            irpStack->MajorFunction = IRP_MJ_SCSI;
            irpStack->Parameters.Scsi.Srb = srb;

            if (!(irpStack->Parameters.Others.Argument1)) {

                //
                // Only jam this in if it doesn't exist. The completion routines can
                // call StartIo directly in the case of retries and resetting it will
                // cause infinite loops.
                //

                irpStack->Parameters.Others.Argument1 = (PVOID) MAXIMUM_RETRIES;
            }

            //
            // Set up IoCompletion routine address.
            //

            IoSetCompletionRoutine(realIrp,
                                   CdRomXACompletion,
                                   srb,
                                   TRUE,
                                   TRUE,
                                   TRUE);
        } else {

            ULONG maximumTransferLength = deviceExtension->PortCapabilities->MaximumTransferLength;
            ULONG transferPages = ADDRESS_AND_SIZE_TO_SPAN_PAGES(MmGetMdlVirtualAddress(realIrp->MdlAddress),
                                                                 realIrpStack->Parameters.Read.Length);
            //
            // Back to cooked sectors. Build and send a normal read.
            // The real work for setting offsets and checking for splitrequests was
            // done in startio
            //

            if ((realIrpStack->Parameters.Read.Length > maximumTransferLength) ||
                (transferPages > deviceExtension->PortCapabilities->MaximumPhysicalPages)) {

                //
                // Request needs to be split. Completion of each portion of the request will
                // fire off the next portion. The final request will signal Io to send a new request.
                //

                ScsiClassSplitRequest(DeviceObject, realIrp, maximumTransferLength);
                return STATUS_MORE_PROCESSING_REQUIRED;

            } else {

                //
                // Build SRB and CDB for this IRP.
                //

                ScsiClassBuildRequest(DeviceObject, realIrp);

            }
        }

        //
        // Call the port driver.
        //

        IoCallDriver(deviceExtension->PortDeviceObject, realIrp);

        return STATUS_MORE_PROCESSING_REQUIRED;
    }

    //
    // Update device Extension flags to indicate that XA isn't supported.
    //

    cdData->XAFlags |= XA_NOT_SUPPORTED;

    //
    // Deallocate srb and sense buffer.
    //

    if (srb) {
        if (srb->DataBuffer) {
            ExFreePool(srb->DataBuffer);
        }
        if (srb->SenseInfoBuffer) {
            ExFreePool(srb->SenseInfoBuffer);
        }
        ExFreePool(srb);
    }

    if (Irp->PendingReturned) {
      IoMarkIrpPending(Irp);
    }

    if (realIrp->PendingReturned) {
        IoMarkIrpPending(realIrp);
    }

    if (Irp->MdlAddress) {
        IoFreeMdl(Irp->MdlAddress);
    }

    IoFreeIrp(Irp);

    //
    // Set status in completing IRP.
    //

    realIrp->IoStatus.Status = status;

    //
    // Set the hard error if necessary.
    //

    if (!NT_SUCCESS(status) && IoIsErrorUserInduced(status)) {

        //
        // Store DeviceObject for filesystem, and clear
        // in IoStatus.Information field.
        //

        IoSetHardErrorOrVerifyDevice(realIrp, DeviceObject);
        realIrp->IoStatus.Information = 0;
    }

    IoCompleteRequest(realIrp, IO_DISK_INCREMENT);

    IoStartNextPacket(DeviceObject, FALSE);

    return STATUS_MORE_PROCESSING_REQUIRED;
}

CdRomTickHandler()

VOID NTAPI CdRomTickHandler	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PVOID	Context
	)

Definition at line 6132 of file cdrom.c.

{
    PIRP              irp;
    PIRP              heldIrpList;
    PIRP              nextIrp;
    PLIST_ENTRY       listEntry;
    PCDROM_DATA       cddata;
    PIO_STACK_LOCATION irpStack;
    PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;

    cddata = (PCDROM_DATA)(deviceExtension + 1);

    if (cddata->MediaChange) {
        if (cddata->MediaChangeIrp != NULL) {

            //
            // Media change support is active and the IRP is waiting.
            // Decrement the timer.
            // There is no MP protection on the timer counter.  This
            // code is the only code that will manipulate the timer
            // and only one instance of it should be running at any
            // given time.
            //

            cddata->MediaChangeCountDown--;

#if DBG
            cddata->MediaChangeIrpTimeInUse = 0;
            cddata->MediaChangeIrpLost = FALSE;
#endif

            if (!cddata->MediaChangeCountDown) {
                PSCSI_REQUEST_BLOCK srb;
                PIO_STACK_LOCATION  irpNextStack;
                PCDB cdb;

                //
                // Reset the timer.
                //

                cddata->MediaChangeCountDown = MEDIA_CHANGE_DEFAULT_TIME;

                //
                // Prepare the IRP for the test unit ready
                //

                irp = cddata->MediaChangeIrp;
                cddata->MediaChangeIrp = NULL;

                irp->IoStatus.Status = STATUS_SUCCESS;
                irp->IoStatus.Information = 0;
                irp->Flags = 0;
                irp->UserBuffer = NULL;

                //
                // If the irp is sent down when the volume needs to be
                // verified, CdRomUpdateGeometryCompletion won't complete
                // it since it's not associated with a thread.  Marking
                // it to override the verify causes it always be sent
                // to the port driver
                //

                irpStack = IoGetCurrentIrpStackLocation(irp);
                irpStack->Flags |= SL_OVERRIDE_VERIFY_VOLUME;

                irpNextStack = IoGetNextIrpStackLocation(irp);
                irpNextStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
                irpNextStack->Parameters.DeviceIoControl.IoControlCode =
                    IOCTL_SCSI_EXECUTE_NONE;

                //
                // Prepare the SRB for execution.
                //

                srb = irpNextStack->Parameters.Scsi.Srb;
                srb->SrbStatus = srb->ScsiStatus = 0;
                srb->NextSrb = 0;
                srb->Length = SCSI_REQUEST_BLOCK_SIZE;
                srb->PathId = deviceExtension->PathId;
                srb->TargetId = deviceExtension->TargetId;
                srb->Lun = deviceExtension->Lun;
                srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
                srb->SrbFlags = SRB_FLAGS_NO_DATA_TRANSFER |
                                SRB_FLAGS_DISABLE_SYNCH_TRANSFER;
                srb->DataTransferLength = 0;
                srb->OriginalRequest = irp;

                RtlZeroMemory(srb->SenseInfoBuffer, SENSE_BUFFER_SIZE);
                srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE;

                cdb = (PCDB) &srb->Cdb[0];
                cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;
                cdb->CDB6GENERIC.LogicalUnitNumber = srb->Lun;

                //
                // Setup the IRP to perform a test unit ready.
                //

                IoSetCompletionRoutine(irp,
                                       CdRomMediaChangeCompletion,
                                       srb,
                                       TRUE,
                                       TRUE,
                                       TRUE);

                //
                // Issue the request.
                //

                IoStartPacket(DeviceObject, irp, NULL, NULL);
            }
        } else {

#if DBG
            if(cddata->MediaChangeIrpLost == FALSE) {
                if(cddata->MediaChangeIrpTimeInUse++ >
                   MEDIA_CHANGE_TIMEOUT_TIME) {

                    DebugPrint((0, "CdRom%d: AutoPlay has lost it's irp and "
                                   "doesn't know where to find it.  Leave it "
                                   "alone and it'll come home dragging it's "
                                   "stack behind it.\n",
                                   deviceExtension->DeviceNumber));
                    cddata->MediaChangeIrpLost = TRUE;
                }
            }

#endif
        }
    }

    //
    // Process all generic timer IRPS in the timer list.  As IRPs are pulled
    // off of the TimerIrpList they must be remembered in the first loop
    // if they are not sent to the lower driver.  After all items have
    // been pulled off the list, it is possible to put the held IRPs back
    // into the TimerIrpList.
    //

    heldIrpList = NULL;
    if (IsListEmpty(&cddata->TimerIrpList)) {
        listEntry = NULL;
    } else {
        listEntry = ExInterlockedRemoveHeadList(&cddata->TimerIrpList,
                                                &cddata->TimerIrpSpinLock);
    }
    while (listEntry) {

        //
        // There is something in the timer list.  Pick up the IRP and
        // see if it is ready to be submitted.
        //

        irp = CONTAINING_RECORD(listEntry, IRP, Tail.Overlay.ListEntry);
        irpStack = IoGetCurrentIrpStackLocation(irp);

        if (irpStack->Parameters.Others.Argument3) {
            ULONG_PTR count;

            //
            // Decrement the countdown timer and put the IRP back in the list.
            //

            count = (ULONG_PTR) irpStack->Parameters.Others.Argument3;
            count--;
            irpStack->Parameters.Others.Argument3 = (PVOID) count;

            ASSERT(irp->AssociatedIrp.MasterIrp == NULL);
            if (heldIrpList) {
                irp->AssociatedIrp.MasterIrp = (PVOID) heldIrpList;
            }
            heldIrpList = irp;

        } else {

            //
            // Submit this IRP to the lower driver.  This IRP does not
            // need to be remembered here.  It will be handled again when
            // it completes.
            //

            DebugPrint((1, "CdRomTickHandler: Reissuing request %lx (thread = %lx)\n", irp, irp->Tail.Overlay.Thread));

            //
            // feed this to the appropriate port driver
            //

            IoCallDriver (deviceExtension->PortDeviceObject, irp);

        }

        //
        // Pick up the next IRP from the timer list.
        //

        listEntry = ExInterlockedRemoveHeadList(&cddata->TimerIrpList,
                                                &cddata->TimerIrpSpinLock);
    }

    //
    // Move all held IRPs back onto the timer list.
    //

    while (heldIrpList) {

        //
        // Save the single list pointer before queueing this IRP.
        //

        nextIrp = (PIRP) heldIrpList->AssociatedIrp.MasterIrp;
        heldIrpList->AssociatedIrp.MasterIrp = NULL;

        //
        // Return the held IRP to the timer list.
        //

        ExInterlockedInsertTailList(&cddata->TimerIrpList,
                                    &heldIrpList->Tail.Overlay.ListEntry,
                                    &cddata->TimerIrpSpinLock);

        //
        // Continue processing the held IRPs
        //

        heldIrpList = nextIrp;
    }
}

Referenced by CdRomRemoveDevice(), CreateCdRomDeviceObject(), and DriverEntry().

CdRomUpdateCapacity()

NTSTATUS NTAPI CdRomUpdateCapacity	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PIRP	IrpToComplete,
		IN OPTIONAL PKEVENT	IoctlEvent
	)

Definition at line 7151 of file cdrom.c.

{
    PCDB                cdb;
    PIRP                irp;
    PSCSI_REQUEST_BLOCK srb;
    PREAD_CAPACITY_DATA capacityBuffer;
    PIO_STACK_LOCATION  irpStack;
    PUCHAR              senseBuffer;

    irp = IoAllocateIrp((CCHAR)(DeviceExtension->DeviceObject->StackSize+1),
                        FALSE);

    if (irp) {

        srb = ExAllocatePool(NonPagedPool, sizeof(SCSI_REQUEST_BLOCK));
        if (srb) {
            capacityBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
                                            sizeof(READ_CAPACITY_DATA));

            if (capacityBuffer) {


                senseBuffer = ExAllocatePool(NonPagedPoolCacheAligned, SENSE_BUFFER_SIZE);

                if (senseBuffer) {

                    irp->MdlAddress = IoAllocateMdl(capacityBuffer,
                                                    sizeof(READ_CAPACITY_DATA),
                                                    FALSE,
                                                    FALSE,
                                                    (PIRP) NULL);

                    if (irp->MdlAddress) {

                        //
                        // Have all resources.  Set up the IRP to send for the capacity.
                        //

                        IoSetNextIrpStackLocation(irp);
                        irp->IoStatus.Status = STATUS_SUCCESS;
                        irp->IoStatus.Information = 0;
                        irp->Flags = 0;
                        irp->UserBuffer = NULL;

                        //
                        // Save the device object and retry count in a private stack location.
                        //

                        irpStack = IoGetCurrentIrpStackLocation(irp);
                        irpStack->DeviceObject = DeviceExtension->DeviceObject;
                        irpStack->Parameters.Others.Argument1 = (PVOID) MAXIMUM_RETRIES;
                        irpStack->Parameters.Others.Argument2 = (PVOID) IrpToComplete;

                        //
                        // Construct the IRP stack for the lower level driver.
                        //

                        irpStack = IoGetNextIrpStackLocation(irp);
                        irpStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
                        irpStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_SCSI_EXECUTE_IN;
                        irpStack->Parameters.Scsi.Srb = srb;
                        IoSetCompletionRoutine(irp,
                                               CdRomUpdateGeometryCompletion,
                                               srb,
                                               TRUE,
                                               TRUE,
                                               TRUE);
                        //
                        // Prepare the MDL
                        //

                        MmBuildMdlForNonPagedPool(irp->MdlAddress);


                        //
                        // Set up the SRB for read capacity.
                        //

                        RtlZeroMemory(srb, sizeof(SCSI_REQUEST_BLOCK));
                        RtlZeroMemory(senseBuffer, SENSE_BUFFER_SIZE);
                        srb->CdbLength = 10;
                        srb->TimeOutValue = DeviceExtension->TimeOutValue;
                        srb->SrbStatus = srb->ScsiStatus = 0;
                        srb->NextSrb = 0;
                        srb->Length = SCSI_REQUEST_BLOCK_SIZE;
                        srb->PathId = DeviceExtension->PathId;
                        srb->TargetId = DeviceExtension->TargetId;
                        srb->Lun = DeviceExtension->Lun;
                        srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
                        srb->SrbFlags = SRB_FLAGS_DATA_IN | SRB_FLAGS_DISABLE_SYNCH_TRANSFER;
                        srb->DataBuffer = capacityBuffer;
                        srb->DataTransferLength = sizeof(READ_CAPACITY_DATA);
                        srb->OriginalRequest = irp;
                        srb->SenseInfoBuffer = senseBuffer;
                        srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE;

                        //
                        // Set up the CDB
                        //

                        cdb = (PCDB) &srb->Cdb[0];
                        cdb->CDB10.OperationCode = SCSIOP_READ_CAPACITY;
                        cdb->CDB10.LogicalUnitNumber = DeviceExtension->Lun;

                        //
                        // Set the return value in the IRP that will be completed
                        // upon completion of the read capacity.
                        //

                        IrpToComplete->IoStatus.Status = STATUS_IO_DEVICE_ERROR;
                        IoMarkIrpPending(IrpToComplete);

                        IoCallDriver(DeviceExtension->PortDeviceObject, irp);

                        //
                        // status is not checked because the completion routine for this
                        // IRP will always get called and it will free the resources.
                        //

                        return STATUS_PENDING;

                    } else {
                        ExFreePool(senseBuffer);
                        ExFreePool(capacityBuffer);
                        ExFreePool(srb);
                        IoFreeIrp(irp);
                    }
                } else {
                    ExFreePool(capacityBuffer);
                    ExFreePool(srb);
                    IoFreeIrp(irp);
                }
            } else {
                ExFreePool(srb);
                IoFreeIrp(irp);
            }
        } else {
            IoFreeIrp(irp);
        }
    }

    return STATUS_INSUFFICIENT_RESOURCES;
}

Referenced by CdRomDeviceControlCompletion(), CdRomStartIo(), and ScsiCdRomStartIo().

CdRomUpdateGeometryCompletion()

NTSTATUS NTAPI CdRomUpdateGeometryCompletion	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PVOID	Context
	)

Definition at line 6899 of file cdrom.c.

{
    PSCSI_REQUEST_BLOCK srb = (PSCSI_REQUEST_BLOCK) Context;
    PREAD_CAPACITY_DATA readCapacityBuffer;
    PDEVICE_EXTENSION   deviceExtension;
    PIO_STACK_LOCATION  irpStack;
    NTSTATUS            status;
    BOOLEAN             retry;
    ULONG_PTR           retryCount;
    ULONG               lastSector;
    PIRP                originalIrp;
    PCDROM_DATA         cddata;

    //
    // Get items saved in the private IRP stack location.
    //

    irpStack = IoGetCurrentIrpStackLocation(Irp);
    retryCount = (ULONG_PTR) irpStack->Parameters.Others.Argument1;
    originalIrp = (PIRP) irpStack->Parameters.Others.Argument2;

    if (!DeviceObject) {
        DeviceObject = irpStack->DeviceObject;
    }
    ASSERT(DeviceObject);

    deviceExtension = DeviceObject->DeviceExtension;
    cddata = (PCDROM_DATA) (deviceExtension + 1);
    readCapacityBuffer = srb->DataBuffer;

    if ((NT_SUCCESS(Irp->IoStatus.Status)) && (SRB_STATUS(srb->SrbStatus) == SRB_STATUS_SUCCESS)) {
        PFOUR_BYTE from;
        PFOUR_BYTE to;

        DebugPrint((2, "CdRomUpdateCapacityCompletion: [%lx] successful completion of buddy-irp %lx\n", originalIrp, Irp));
        //
        // Copy sector size from read capacity buffer to device extension
        // in reverse byte order.
        //

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

        //
        // Using the new BytesPerBlock, calculate and store the SectorShift.
        //

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

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

        from = (PFOUR_BYTE) &readCapacityBuffer->LogicalBlockAddress;
        to = (PFOUR_BYTE) &lastSector;
        to->Byte0 = from->Byte3;
        to->Byte1 = from->Byte2;
        to->Byte2 = from->Byte1;
        to->Byte3 = from->Byte0;
        deviceExtension->PartitionLength.QuadPart = (LONGLONG)(lastSector + 1);

        //
        // Calculate number of cylinders.
        //

        deviceExtension->DiskGeometry->Geometry.Cylinders.QuadPart = (LONGLONG)((lastSector + 1)/(32 * 64));
        deviceExtension->PartitionLength.QuadPart =
            (deviceExtension->PartitionLength.QuadPart << deviceExtension->SectorShift);
        deviceExtension->DiskGeometry->Geometry.MediaType = RemovableMedia;

        //
        // Assume sectors per track are 32;
        //

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

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

        deviceExtension->DiskGeometry->Geometry.TracksPerCylinder = 64;

    } else {

        DebugPrint((1, "CdRomUpdateCapacityCompletion: [%lx] unsuccessful completion of buddy-irp %lx (status - %lx)\n", originalIrp, Irp, Irp->IoStatus.Status));

        if (srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN) {
            ScsiClassReleaseQueue(DeviceObject);
        }

        retry = ScsiClassInterpretSenseInfo(DeviceObject,
                                            srb,
                                            IRP_MJ_SCSI,
                                            0,
                                            retryCount,
                                            &status);
        if (retry) {
            retryCount--;
            if (retryCount) {
                PCDB cdb;

                DebugPrint((1, "CdRomUpdateCapacityCompletion: [%lx] Retrying request %lx .. thread is %lx\n", originalIrp, Irp, Irp->Tail.Overlay.Thread));
                //
                // set up a one shot timer to get this process started over
                //

                irpStack->Parameters.Others.Argument1 = (PVOID) retryCount;
                irpStack->Parameters.Others.Argument2 = (PVOID) originalIrp;
                irpStack->Parameters.Others.Argument3 = (PVOID) 2;

                //
                // Setup the IRP to be submitted again in the timer routine.
                //

                irpStack = IoGetNextIrpStackLocation(Irp);
                irpStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
                irpStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_SCSI_EXECUTE_IN;
                irpStack->Parameters.Scsi.Srb = srb;
                IoSetCompletionRoutine(Irp,
                                       CdRomUpdateGeometryCompletion,
                                       srb,
                                       TRUE,
                                       TRUE,
                                       TRUE);

                //
                // Set up the SRB for read capacity.
                //

                srb->CdbLength = 10;
                srb->TimeOutValue = deviceExtension->TimeOutValue;
                srb->SrbStatus = srb->ScsiStatus = 0;
                srb->NextSrb = 0;
                srb->Length = SCSI_REQUEST_BLOCK_SIZE;
                srb->PathId = deviceExtension->PathId;
                srb->TargetId = deviceExtension->TargetId;
                srb->Lun = deviceExtension->Lun;
                srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
                srb->SrbFlags = SRB_FLAGS_DATA_IN | SRB_FLAGS_DISABLE_SYNCH_TRANSFER;
                srb->DataTransferLength = sizeof(READ_CAPACITY_DATA);

                //
                // Set up the CDB
                //

                cdb = (PCDB) &srb->Cdb[0];
                cdb->CDB10.OperationCode = SCSIOP_READ_CAPACITY;
                cdb->CDB10.LogicalUnitNumber = deviceExtension->Lun;

                //
                // Requests queued onto this list will be sent to the
                // lower level driver during CdRomTickHandler
                //

                ExInterlockedInsertHeadList(&cddata->TimerIrpList,
                                            &Irp->Tail.Overlay.ListEntry,
                                            &cddata->TimerIrpSpinLock);

                return STATUS_MORE_PROCESSING_REQUIRED;
            } else {

                //
                // This has been bounced for a number of times.  Error the
                // original request.
                //

                originalIrp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
                RtlZeroMemory(deviceExtension->DiskGeometry, sizeof(DISK_GEOMETRY_EX));
                deviceExtension->DiskGeometry->Geometry.BytesPerSector = 2048;
                deviceExtension->SectorShift = 11;
                deviceExtension->PartitionLength.QuadPart = (LONGLONG)(0x7fffffff);
                deviceExtension->DiskGeometry->Geometry.MediaType = RemovableMedia;
            }
        } else {

            //
            // Set up reasonable defaults
            //

            RtlZeroMemory(deviceExtension->DiskGeometry, sizeof(DISK_GEOMETRY_EX));
            deviceExtension->DiskGeometry->Geometry.BytesPerSector = 2048;
            deviceExtension->SectorShift = 11;
            deviceExtension->PartitionLength.QuadPart = (LONGLONG)(0x7fffffff);
            deviceExtension->DiskGeometry->Geometry.MediaType = RemovableMedia;
        }
    }

    //
    // Free resources held.
    //

    ExFreePool(srb->SenseInfoBuffer);
    ExFreePool(srb->DataBuffer);
    ExFreePool(srb);
    if (Irp->MdlAddress) {
        IoFreeMdl(Irp->MdlAddress);
    }
    IoFreeIrp(Irp);
    if (originalIrp->Tail.Overlay.Thread) {

        DebugPrint((2, "CdRomUpdateCapacityCompletion: [%lx] completing original IRP\n", originalIrp));
        IoCompleteRequest(originalIrp, IO_DISK_INCREMENT);

    } else {
        DebugPrint((1, "CdRomUpdateCapacityCompletion: [%lx] original irp has "
                       "no thread\n",
                    originalIrp
                  ));
    }

    //
    // It's now safe to either start the next request or let the waiting ioctl
    // request continue along it's merry way
    //

    IoStartNextPacket(DeviceObject, FALSE);

    return STATUS_MORE_PROCESSING_REQUIRED;
}

CdRomXACompletion()

NTSTATUS NTAPI CdRomXACompletion	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PVOID	Context
	)

Definition at line 4529 of file cdrom.c.

{
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PIO_STACK_LOCATION irpNextStack = IoGetNextIrpStackLocation(Irp);
    PSCSI_REQUEST_BLOCK srb = Context;
    NTSTATUS status;
    BOOLEAN retry;

    //
    // Check SRB status for success of completing request.
    //

    if (SRB_STATUS(srb->SrbStatus) != SRB_STATUS_SUCCESS) {

        DebugPrint((2,"ScsiClassIoComplete: IRP %lx, SRB %lx\n", Irp, srb));

        //
        // Release the queue if it is frozen.
        //

        if (srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN) {
            ScsiClassReleaseQueue(DeviceObject);
        }

        retry = ScsiClassInterpretSenseInfo(
            DeviceObject,
            srb,
            irpStack->MajorFunction,
            irpStack->MajorFunction == IRP_MJ_DEVICE_CONTROL ? irpStack->Parameters.DeviceIoControl.IoControlCode : 0,
            MAXIMUM_RETRIES - ((ULONG_PTR)irpNextStack->Parameters.Others.Argument1),
            &status);

        //
        // If the status is verified required and the this request
        // should bypass verify required then retry the request.
        //

        if (irpStack->Flags & SL_OVERRIDE_VERIFY_VOLUME &&
            status == STATUS_VERIFY_REQUIRED) {

            status = STATUS_IO_DEVICE_ERROR;
            retry = TRUE;
        }

        if (retry && (irpNextStack->Parameters.Others.Argument1 = (PVOID)((ULONG_PTR)irpNextStack->Parameters.Others.Argument1-1))) {

            if (((ULONG_PTR)irpNextStack->Parameters.Others.Argument1)) {

                //
                // Retry request.
                //

                DebugPrint((1, "CdRomXACompletion: Retry request %lx - Calling StartIo\n", Irp));


                ExFreePool(srb->SenseInfoBuffer);
                ExFreePool(srb->DataBuffer);
                ExFreePool(srb);

                //
                // Call StartIo directly since IoStartNextPacket hasn't been called,
                // the serialisation is still intact.
                //

                ScsiCdRomStartIo(DeviceObject, Irp);
                return STATUS_MORE_PROCESSING_REQUIRED;

            }

            //
            // Exhausted retries. Fall through and complete the request with the appropriate status.
            //
        }
    } else {

        //
        // Set status for successful request.
        //

        status = STATUS_SUCCESS;

    } // end if (SRB_STATUS(srb->SrbStatus) ...

    //
    // Return SRB to nonpaged pool.
    //

    ExFreePool(srb);

    //
    // Set status in completing IRP.
    //

    Irp->IoStatus.Status = status;

    //
    // Set the hard error if necessary.
    //

    if (!NT_SUCCESS(status) && IoIsErrorUserInduced(status)) {

        //
        // Store DeviceObject for filesystem, and clear
        // in IoStatus.Information field.
        //

        IoSetHardErrorOrVerifyDevice(Irp, DeviceObject);
        Irp->IoStatus.Information = 0;
    }

    //
    // If pending has be returned for this irp then mark the current stack as
    // pending.
    //

    if (Irp->PendingReturned) {
      IoMarkIrpPending(Irp);
    }

    //IoCompleteRequest(Irp, IO_DISK_INCREMENT);
    IoStartNextPacket(DeviceObject, FALSE);

    return status;
}