cdrom.h File Reference

#include <ntddk.h>
#include <ntddcdvd.h>
#include <classpnp.h>
#include <ntddmmc.h>
#include "trace.h"

Include dependency graph for cdrom.h:

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

Go to the source code of this file.

Classes
struct	_XA_CONTEXT
struct	_ERROR_RECOVERY_DATA
struct	_ERROR_RECOVERY_DATA10
struct	_CDROM_DRIVER_EXTENSION
struct	_CDROM_MMC_EXTENSION
struct	_CDROM_DATA

Macros
#define	CDROM_GET_CONFIGURATION_TIMEOUT   (0x4)
#define	CDROM_HACK_DEC_RRD   (0x00000001)
#define	CDROM_HACK_FUJITSU_FMCD_10x   (0x00000002)
#define	CDROM_HACK_HITACHI_1750   (0x00000004)
#define	CDROM_HACK_HITACHI_GD_2000   (0x00000008)
#define	CDROM_HACK_TOSHIBA_SD_W1101   (0x00000010)
#define	CDROM_HACK_TOSHIBA_XM_3xx   (0x00000020)
#define	CDROM_HACK_NEC_CDDA   (0x00000040)
#define	CDROM_HACK_PLEXTOR_CDDA   (0x00000080)
#define	CDROM_HACK_BAD_GET_CONFIG_SUPPORT   (0x00000100)
#define	CDROM_HACK_FORCE_READ_CD_DETECTION   (0x00000200)
#define	CDROM_HACK_READ_CD_SUPPORTED   (0x00000400)
#define	CDROM_HACK_LOCKED_PAGES   (0x80000000)
#define	CDROM_HACK_VALID_FLAGS   (0x000007ff)
#define	CDROM_HACK_INVALID_FLAGS   (~CDROM_HACK_VALID_FLAGS)
#define	CdromMmcUpdateComplete   0
#define	CdromMmcUpdateRequired   1
#define	CdromMmcUpdateStarted   2
#define	CDROM_DRIVER_EXTENSION_ID   CdRomAddDevice
#define	DEVICE_EXTENSION_SIZE   sizeof(FUNCTIONAL_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	CDROM_SRB_LIST_SIZE   4
#define	PLAY_ACTIVE(x)   (((PCDROM_DATA)(x->CommonExtension.DriverData))->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_NOT_SUPPORTED   0x10
#define	XA_USE_READ_CD   0x20
#define	XA_PLEXTOR_CDDA   0x40
#define	XA_NEC_CDDA   0x80
#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	MAX_COPY_PROTECT_AGID   4
#define	CDROM_TAG_GET_CONFIG   'cCcS'
#define	CDROM_TAG_DC_EVENT   'ECcS'
#define	CDROM_TAG_FEATURE   'FCcS'
#define	CDROM_TAG_DISK_GEOM   'GCcS'
#define	CDROM_TAG_HITACHI_ERROR   'HCcS'
#define	CDROM_TAG_SENSE_INFO   'ICcS'
#define	CDROM_TAG_POWER_IRP   'iCcS'
#define	CDROM_TAG_SRB   'SCcS'
#define	CDROM_TAG_STRINGS   'sCcS'
#define	CDROM_TAG_MODE_DATA   'MCcS'
#define	CDROM_TAG_READ_CAP   'PCcS'
#define	CDROM_TAG_PLAY_ACTIVE   'pCcS'
#define	CDROM_TAG_SUB_Q   'QCcS'
#define	CDROM_TAG_RAW   'RCcS'
#define	CDROM_TAG_TOC   'TCcS'
#define	CDROM_TAG_TOSHIBA_ERROR   'tCcS'
#define	CDROM_TAG_DEC_ERROR   'dCcS'
#define	CDROM_TAG_UPDATE_CAP   'UCcS'
#define	CDROM_TAG_VOLUME   'VCcS'
#define	CDROM_TAG_VOLUME_INT   'vCcS'
#define	DVD_TAG_READ_STRUCTURE   'SVcS'
#define	DVD_TAG_READ_KEY   'kVcS'
#define	DVD_TAG_SEND_KEY   'KVcS'
#define	DVD_TAG_RPC2_CHECK   'sVcS'
#define	DVD_TAG_DVD_REGION   'tVcS'
#define	DVD_TAG_SECURITY   'XVcS'
#define	CDROM_SUBKEY_NAME   (L"CdRom")
#define	CDROM_READ_CD_NAME   (L"ReadCD")
#define	CDROM_NON_MMC_DRIVE_NAME   (L"NonMmc")
#define	DVD_DEFAULT_REGION   (L"DefaultDvdRegion")
#define	DVD_CURRENT_REGION   (L"DvdR")
#define	DVD_REGION_RESET_COUNT   (L"DvdRCnt")
#define	DVD_MAX_REGION_RESET_COUNT   2
#define	DVD_MAX_REGION   8
#define	BAIL_OUT(Irp)

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_DRIVER_EXTENSION	CDROM_DRIVER_EXTENSION
typedef struct _CDROM_DRIVER_EXTENSION *	PCDROM_DRIVER_EXTENSION
typedef struct _CDROM_MMC_EXTENSION	CDROM_MMC_EXTENSION
typedef struct _CDROM_MMC_EXTENSION *	PCDROM_MMC_EXTENSION
typedef struct _CDROM_DATA	CDROM_DATA
typedef struct _CDROM_DATA *	PCDROM_DATA

Enumerations
enum	CdromError {   CdromDebugError = 0, CdromDebugWarning = 1, CdromDebugTrace = 2, CdromDebugInfo = 3,   CdromDebugFeatures = 32 }

Functions
static VOID	CdRomCompleteIrpAndStartNextPacketSafely (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI	CdRomDeviceControlDvdReadStructure (IN PDEVICE_OBJECT DeviceObject, IN PIRP OriginalIrp, IN PIRP NewIrp, IN PSCSI_REQUEST_BLOCK Srb)
VOID NTAPI	CdRomDeviceControlDvdEndSession (IN PDEVICE_OBJECT DeviceObject, IN PIRP OriginalIrp, IN PIRP NewIrp, IN PSCSI_REQUEST_BLOCK Srb)
VOID NTAPI	CdRomDeviceControlDvdStartSessionReadKey (IN PDEVICE_OBJECT DeviceObject, IN PIRP OriginalIrp, IN PIRP NewIrp, IN PSCSI_REQUEST_BLOCK Srb)
VOID NTAPI	CdRomDeviceControlDvdSendKey (IN PDEVICE_OBJECT DeviceObject, IN PIRP OriginalIrp, IN PIRP NewIrp, IN PSCSI_REQUEST_BLOCK Srb)
NTSTATUS NTAPI	DriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
VOID NTAPI	CdRomUnload (IN PDRIVER_OBJECT DriverObject)
NTSTATUS NTAPI	CdRomAddDevice (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT Pdo)
NTSTATUS NTAPI	CdRomOpenClose (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	CdRomReadWriteVerification (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	CdRomSwitchMode (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN PIRP OriginalRequest)
NTSTATUS NTAPI	CdRomDeviceControlDispatch (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	CdRomStartIo (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI	CdRomTickHandler (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI	CdRomUpdateCapacity (IN PFUNCTIONAL_DEVICE_EXTENSION DeviceExtension, IN PIRP IrpToComplete, IN OPTIONAL PKEVENT IoctlEvent)
NTSTATUS NTAPI	CdRomCreateDeviceObject (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT Pdo)
VOID NTAPI	ScanForSpecialHandler (PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, ULONG_PTR HackFlags)
VOID NTAPI	ScanForSpecial (PDEVICE_OBJECT DeviceObject)
BOOLEAN NTAPI	CdRomIsPlayActive (IN PDEVICE_OBJECT DeviceObject)
VOID NTAPI	CdRomErrorHandler (PDEVICE_OBJECT DeviceObject, PSCSI_REQUEST_BLOCK Srb, NTSTATUS *Status, BOOLEAN *Retry)
VOID NTAPI	HitachiProcessErrorGD2000 (PDEVICE_OBJECT DeviceObject, PSCSI_REQUEST_BLOCK Srb, NTSTATUS *Status, BOOLEAN *Retry)
VOID NTAPI	HitachiProcessError (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)
NTSTATUS NTAPI	ToshibaProcessErrorCompletion (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
VOID NTAPI	CdRomCreateNamedEvent (IN PFUNCTIONAL_DEVICE_EXTENSION DeviceExtension, IN ULONG DeviceNumber)
NTSTATUS NTAPI	CdRomInitDevice (IN PDEVICE_OBJECT Fdo)
NTSTATUS NTAPI	CdRomStartDevice (IN PDEVICE_OBJECT Fdo)
NTSTATUS NTAPI	CdRomStopDevice (IN PDEVICE_OBJECT DeviceObject, IN UCHAR Type)
NTSTATUS NTAPI	CdRomRemoveDevice (IN PDEVICE_OBJECT DeviceObject, IN UCHAR Type)
NTSTATUS NTAPI	CdRomDvdEndAllSessionsCompletion (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
NTSTATUS NTAPI	CdRomDvdReadDiskKeyCompletion (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
DEVICE_TYPE NTAPI	CdRomGetDeviceType (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI	CdRomCreateWellKnownName (IN PDEVICE_OBJECT DeviceObject)
VOID NTAPI	CdRomDeleteWellKnownName (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI	CdRomGetDeviceParameter (IN PDEVICE_OBJECT DeviceObject, IN PWSTR ParameterName, IN OUT PULONG ParameterValue)
NTSTATUS NTAPI	CdRomSetDeviceParameter (IN PDEVICE_OBJECT DeviceObject, IN PWSTR ParameterName, IN ULONG ParameterValue)
VOID NTAPI	CdRomPickDvdRegion (IN PDEVICE_OBJECT Fdo)
NTSTATUS NTAPI	CdRomRetryRequest (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN PIRP Irp, IN ULONG Delay, IN BOOLEAN ResendIrp)
NTSTATUS NTAPI	CdRomRerunRequest (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN OPTIONAL PIRP Irp, IN BOOLEAN ResendIrp)
NTSTATUS NTAPI	CdRomGetRpc0Settings (IN PDEVICE_OBJECT Fdo)
NTSTATUS NTAPI	CdRomSetRpc0Settings (IN PDEVICE_OBJECT Fdo, IN UCHAR NewRegion)
NTSTATUS NTAPI	CdRomShutdownFlush (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI	CdRomIsDeviceMmcDevice (IN PDEVICE_OBJECT Fdo, OUT PBOOLEAN IsMmc)
VOID NTAPI	CdRomMmcErrorHandler (IN PDEVICE_OBJECT Fdo, IN PSCSI_REQUEST_BLOCK Srb, OUT PNTSTATUS Status, OUT PBOOLEAN Retry)
PVOID NTAPI	CdRomFindFeaturePage (IN PGET_CONFIGURATION_HEADER FeatureBuffer, IN ULONG Length, IN FEATURE_NUMBER Feature)
NTSTATUS NTAPI	CdRomGetConfiguration (IN PDEVICE_OBJECT Fdo, OUT PGET_CONFIGURATION_HEADER *Buffer, OUT PULONG BytesReturned, IN FEATURE_NUMBER StartingFeature, IN ULONG RequestedType)
VOID NTAPI	CdRomUpdateMmcDriveCapabilities (IN PDEVICE_OBJECT Fdo, IN PVOID Context)
VOID NTAPI	CdRomFindProfileInProfiles (IN PFEATURE_DATA_PROFILE_LIST ProfileHeader, IN FEATURE_PROFILE_TYPE ProfileToFind, OUT PBOOLEAN Exists)
NTSTATUS NTAPI	CdRomAllocateMmcResources (IN PDEVICE_OBJECT Fdo)
VOID NTAPI	CdRomDeAllocateMmcResources (IN PDEVICE_OBJECT Fdo)
VOID NTAPI	CdromFakePartitionInfo (IN PCOMMON_DEVICE_EXTENSION CommonExtension, IN PIRP Irp)
VOID NTAPI	CdRomInterpretReadCapacity (IN PDEVICE_OBJECT Fdo, IN PREAD_CAPACITY_DATA ReadCapacityBuffer)
NTSTATUS NTAPI	CdRomShutdownFlushCompletion (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PIRP Context)
VOID NTAPI	CdRompFlushDelayedList (IN PDEVICE_OBJECT Fdo, IN PCDROM_MMC_EXTENSION MmcData, IN NTSTATUS Status, IN BOOLEAN CalledFromWorkItem)

Variables
CLASSPNP_SCAN_FOR_SPECIAL_INFO	CdromHackItems []

Macro Definition Documentation

ANY_SECTOR

#define ANY_SECTOR   0

Definition at line 307 of file cdrom.h.

BAIL_OUT

#define BAIL_OUT

(

Irp

)

Value:

DebugPrint((2, "Cdrom: [%p] Bailing with status " \
                " %lx at line %x file %s\n",          \
                (Irp), (Irp)->IoStatus.Status,        \
                __LINE__, __FILE__))

Definition at line 362 of file cdrom.h.

CD_DA_SECTOR

#define CD_DA_SECTOR   1

Definition at line 308 of file cdrom.h.

CDROM_DRIVER_EXTENSION_ID

#define CDROM_DRIVER_EXTENSION_ID   CdRomAddDevice

Definition at line 141 of file cdrom.h.

CDROM_GET_CONFIGURATION_TIMEOUT

#define CDROM_GET_CONFIGURATION_TIMEOUT   (0x4)

Definition at line 54 of file cdrom.h.

CDROM_HACK_BAD_GET_CONFIG_SUPPORT

#define CDROM_HACK_BAD_GET_CONFIG_SUPPORT   (0x00000100)

Definition at line 64 of file cdrom.h.

CDROM_HACK_DEC_RRD

#define CDROM_HACK_DEC_RRD   (0x00000001)

Definition at line 56 of file cdrom.h.

CDROM_HACK_FORCE_READ_CD_DETECTION

#define CDROM_HACK_FORCE_READ_CD_DETECTION   (0x00000200)

Definition at line 65 of file cdrom.h.

CDROM_HACK_FUJITSU_FMCD_10x

#define CDROM_HACK_FUJITSU_FMCD_10x   (0x00000002)

Definition at line 57 of file cdrom.h.

CDROM_HACK_HITACHI_1750

#define CDROM_HACK_HITACHI_1750   (0x00000004)

Definition at line 58 of file cdrom.h.

CDROM_HACK_HITACHI_GD_2000

#define CDROM_HACK_HITACHI_GD_2000   (0x00000008)

Definition at line 59 of file cdrom.h.

CDROM_HACK_INVALID_FLAGS

#define CDROM_HACK_INVALID_FLAGS   (~CDROM_HACK_VALID_FLAGS)

Definition at line 70 of file cdrom.h.

CDROM_HACK_LOCKED_PAGES

#define CDROM_HACK_LOCKED_PAGES   (0x80000000)

Definition at line 67 of file cdrom.h.

CDROM_HACK_NEC_CDDA

#define CDROM_HACK_NEC_CDDA   (0x00000040)

Definition at line 62 of file cdrom.h.

CDROM_HACK_PLEXTOR_CDDA

#define CDROM_HACK_PLEXTOR_CDDA   (0x00000080)

Definition at line 63 of file cdrom.h.

CDROM_HACK_READ_CD_SUPPORTED

#define CDROM_HACK_READ_CD_SUPPORTED   (0x00000400)

Definition at line 66 of file cdrom.h.

CDROM_HACK_TOSHIBA_SD_W1101

#define CDROM_HACK_TOSHIBA_SD_W1101   (0x00000010)

Definition at line 60 of file cdrom.h.

CDROM_HACK_TOSHIBA_XM_3xx

#define CDROM_HACK_TOSHIBA_XM_3xx   (0x00000020)

Definition at line 61 of file cdrom.h.

CDROM_HACK_VALID_FLAGS

#define CDROM_HACK_VALID_FLAGS   (0x000007ff)

Definition at line 69 of file cdrom.h.

CDROM_NON_MMC_DRIVE_NAME

#define CDROM_NON_MMC_DRIVE_NAME   (L"NonMmc")

Definition at line 352 of file cdrom.h.

CDROM_READ_CD_NAME

#define CDROM_READ_CD_NAME   (L"ReadCD")

Definition at line 351 of file cdrom.h.

CDROM_SRB_LIST_SIZE

#define CDROM_SRB_LIST_SIZE   4

Definition at line 275 of file cdrom.h.

CDROM_SUBKEY_NAME

#define CDROM_SUBKEY_NAME   (L"CdRom")

Definition at line 350 of file cdrom.h.

CDROM_TAG_DC_EVENT

#define CDROM_TAG_DC_EVENT   'ECcS'

Definition at line 322 of file cdrom.h.

CDROM_TAG_DEC_ERROR

#define CDROM_TAG_DEC_ERROR   'dCcS'

Definition at line 337 of file cdrom.h.

CDROM_TAG_DISK_GEOM

#define CDROM_TAG_DISK_GEOM   'GCcS'

Definition at line 324 of file cdrom.h.

CDROM_TAG_FEATURE

#define CDROM_TAG_FEATURE   'FCcS'

Definition at line 323 of file cdrom.h.

CDROM_TAG_GET_CONFIG

#define CDROM_TAG_GET_CONFIG   'cCcS'

Definition at line 321 of file cdrom.h.

CDROM_TAG_HITACHI_ERROR

#define CDROM_TAG_HITACHI_ERROR   'HCcS'

Definition at line 325 of file cdrom.h.

CDROM_TAG_MODE_DATA

#define CDROM_TAG_MODE_DATA   'MCcS'

Definition at line 330 of file cdrom.h.

CDROM_TAG_PLAY_ACTIVE

#define CDROM_TAG_PLAY_ACTIVE   'pCcS'

Definition at line 332 of file cdrom.h.

CDROM_TAG_POWER_IRP

#define CDROM_TAG_POWER_IRP   'iCcS'

Definition at line 327 of file cdrom.h.

CDROM_TAG_RAW

#define CDROM_TAG_RAW   'RCcS'

Definition at line 334 of file cdrom.h.

CDROM_TAG_READ_CAP

#define CDROM_TAG_READ_CAP   'PCcS'

Definition at line 331 of file cdrom.h.

CDROM_TAG_SENSE_INFO

#define CDROM_TAG_SENSE_INFO   'ICcS'

Definition at line 326 of file cdrom.h.

CDROM_TAG_SRB

#define CDROM_TAG_SRB   'SCcS'

Definition at line 328 of file cdrom.h.

CDROM_TAG_STRINGS

#define CDROM_TAG_STRINGS   'sCcS'

Definition at line 329 of file cdrom.h.

CDROM_TAG_SUB_Q

#define CDROM_TAG_SUB_Q   'QCcS'

Definition at line 333 of file cdrom.h.

CDROM_TAG_TOC

#define CDROM_TAG_TOC   'TCcS'

Definition at line 335 of file cdrom.h.

CDROM_TAG_TOSHIBA_ERROR

#define CDROM_TAG_TOSHIBA_ERROR   'tCcS'

Definition at line 336 of file cdrom.h.

CDROM_TAG_UPDATE_CAP

#define CDROM_TAG_UPDATE_CAP   'UCcS'

Definition at line 338 of file cdrom.h.

CDROM_TAG_VOLUME

#define CDROM_TAG_VOLUME   'VCcS'

Definition at line 339 of file cdrom.h.

CDROM_TAG_VOLUME_INT

#define CDROM_TAG_VOLUME_INT   'vCcS'

Definition at line 340 of file cdrom.h.

CdromMmcUpdateComplete

#define CdromMmcUpdateComplete   0

Definition at line 116 of file cdrom.h.

CdromMmcUpdateRequired

#define CdromMmcUpdateRequired   1

Definition at line 117 of file cdrom.h.

CdromMmcUpdateStarted

#define CdromMmcUpdateStarted   2

Definition at line 118 of file cdrom.h.

COOKED_SECTOR_SIZE

#define COOKED_SECTOR_SIZE   2048

Definition at line 274 of file cdrom.h.

DEC_TO_BCD

#define DEC_TO_BCD

(

x

)

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

Definition at line 289 of file cdrom.h.

DEVICE_EXTENSION_SIZE

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

Definition at line 268 of file cdrom.h.

DVD_CURRENT_REGION

#define DVD_CURRENT_REGION   (L"DvdR")

Definition at line 357 of file cdrom.h.

DVD_DEFAULT_REGION

#define DVD_DEFAULT_REGION   (L"DefaultDvdRegion")

Definition at line 356 of file cdrom.h.

DVD_MAX_REGION

#define DVD_MAX_REGION   8

Definition at line 360 of file cdrom.h.

DVD_MAX_REGION_RESET_COUNT

#define DVD_MAX_REGION_RESET_COUNT   2

Definition at line 359 of file cdrom.h.

DVD_REGION_RESET_COUNT

#define DVD_REGION_RESET_COUNT   (L"DvdRCnt")

Definition at line 358 of file cdrom.h.

DVD_TAG_DVD_REGION

#define DVD_TAG_DVD_REGION   'tVcS'

Definition at line 346 of file cdrom.h.

DVD_TAG_READ_KEY

#define DVD_TAG_READ_KEY   'kVcS'

Definition at line 343 of file cdrom.h.

DVD_TAG_READ_STRUCTURE

#define DVD_TAG_READ_STRUCTURE   'SVcS'

Definition at line 342 of file cdrom.h.

DVD_TAG_RPC2_CHECK

#define DVD_TAG_RPC2_CHECK   'sVcS'

Definition at line 345 of file cdrom.h.

DVD_TAG_SECURITY

#define DVD_TAG_SECURITY   'XVcS'

Definition at line 347 of file cdrom.h.

DVD_TAG_SEND_KEY

#define DVD_TAG_SEND_KEY   'KVcS'

Definition at line 344 of file cdrom.h.

FORM2_MODE1_SECTOR

#define FORM2_MODE1_SECTOR   4

Definition at line 311 of file cdrom.h.

FORM2_MODE2_SECTOR

#define FORM2_MODE2_SECTOR   5

Definition at line 312 of file cdrom.h.

HITACHI_MODE_DATA_SIZE

#define HITACHI_MODE_DATA_SIZE   12

Definition at line 271 of file cdrom.h.

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 282 of file cdrom.h.

MAX_COPY_PROTECT_AGID

#define MAX_COPY_PROTECT_AGID   4

Definition at line 314 of file cdrom.h.

MODE_DATA_SIZE

#define MODE_DATA_SIZE   64

Definition at line 272 of file cdrom.h.

MSF_TO_LBA

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

Definition at line 279 of file cdrom.h.

PLAY_ACTIVE

#define PLAY_ACTIVE

(

x

)

(((PCDROM_DATA)(x->CommonExtension.DriverData))->PlayActive)

Definition at line 277 of file cdrom.h.

RAW_SECTOR_SIZE

#define RAW_SECTOR_SIZE   2352

Definition at line 273 of file cdrom.h.

SCSI_CDROM_TIMEOUT

#define SCSI_CDROM_TIMEOUT   10

Definition at line 269 of file cdrom.h.

SCSI_CHANGER_BONUS_TIMEOUT

#define SCSI_CHANGER_BONUS_TIMEOUT   10

Definition at line 270 of file cdrom.h.

XA_NEC_CDDA

#define XA_NEC_CDDA   0x80

Definition at line 301 of file cdrom.h.

XA_NOT_SUPPORTED

#define XA_NOT_SUPPORTED   0x10

Definition at line 298 of file cdrom.h.

XA_PLEXTOR_CDDA

#define XA_PLEXTOR_CDDA   0x40

Definition at line 300 of file cdrom.h.

XA_USE_10_BYTE

#define XA_USE_10_BYTE   0x02

Definition at line 296 of file cdrom.h.

XA_USE_6_BYTE

#define XA_USE_6_BYTE   0x01

Definition at line 295 of file cdrom.h.

XA_USE_READ_CD

#define XA_USE_READ_CD   0x20

Definition at line 299 of file cdrom.h.

YELLOW_MODE1_SECTOR

#define YELLOW_MODE1_SECTOR   2

Definition at line 309 of file cdrom.h.

YELLOW_MODE2_SECTOR

#define YELLOW_MODE2_SECTOR   3

Definition at line 310 of file cdrom.h.

Typedef Documentation

CDROM_DATA

typedef struct _CDROM_DATA CDROM_DATA

CDROM_DRIVER_EXTENSION

typedef struct _CDROM_DRIVER_EXTENSION CDROM_DRIVER_EXTENSION

CDROM_MMC_EXTENSION

typedef struct _CDROM_MMC_EXTENSION CDROM_MMC_EXTENSION

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

PCDROM_DRIVER_EXTENSION

typedef struct _CDROM_DRIVER_EXTENSION * PCDROM_DRIVER_EXTENSION

PCDROM_MMC_EXTENSION

typedef struct _CDROM_MMC_EXTENSION * PCDROM_MMC_EXTENSION

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

Enumeration Type Documentation

CdromError

enum CdromError

Enumerator
CdromDebugError
CdromDebugWarning
CdromDebugTrace
CdromDebugInfo
CdromDebugFeatures

Definition at line 40 of file cdrom.h.

             {
    CdromDebugError     = 0,  // always printed
    CdromDebugWarning   = 1,  // set bit 0x00000001 in nt!kd_cdrom_mask
    CdromDebugTrace     = 2,  // set bit 0x00000002 in nt!kd_cdrom_mask
    CdromDebugInfo      = 3,  // set bit 0x00000004 in nt!kd_cdrom_mask
#if 0
    CdromDebug          = z,  // set bit 0x00000000 in nt!kd_cdrom_mask
    CdromDebug          = z,  // set bit 0x00000000 in nt!kd_cdrom_mask
    CdromDebug          = z,  // set bit 0x00000000 in nt!kd_cdrom_mask
    CdromDebug          = z,  // set bit 0x00000000 in nt!kd_cdrom_mask
#endif
    CdromDebugFeatures  = 32  // set bit 0x80000000 in nt!kd_cdrom_mask
}CdromError;

Function Documentation

CdRomAddDevice()

NTSTATUS NTAPI CdRomAddDevice	(	IN PDRIVER_OBJECT	DriverObject,
		IN PDEVICE_OBJECT	Pdo
	)

Definition at line 183 of file cdrom.c.

{
    NTSTATUS status;

    PAGED_CODE();

    //
    // Get the address of the count of the number of cdroms already initialized.
    //
    DbgPrint("add device\n");

    status = CdRomCreateDeviceObject(DriverObject,
                                     PhysicalDeviceObject);

    //
    // Note: this always increments driver extension counter
    //       it will eventually wrap, and fail additions
    //       if an existing cdrom has the given number.
    //       so unlikely that we won't even bother considering
    //       this case, since the cure is quite likely worse
    //       than the symptoms.
    //

    if(NT_SUCCESS(status)) {

        //
        // keep track of the total number of active cdroms in IoGet(),
        // as some programs use this to determine when they have found
        // all the cdroms in the system.
        //

        TraceLog((CdromDebugTrace, "CDROM.SYS Add succeeded\n"));
        IoGetConfigurationInformation()->CdRomCount++;

    } else {

        TraceLog((CdromDebugWarning,
                    "CDROM.SYS Add failed! %x\n", status));

    }

    return status;
}

Referenced by DriverEntry().

CdRomAllocateMmcResources()

NTSTATUS NTAPI CdRomAllocateMmcResources

(

IN PDEVICE_OBJECT

Fdo

)

Definition at line 1369 of file mmc.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
    PCDROM_DATA cddata = commonExtension->DriverData;
    PCDROM_MMC_EXTENSION mmcData = &cddata->Mmc;
    PIO_STACK_LOCATION irpStack;
    NTSTATUS status;

    ASSERT(mmcData->CapabilitiesWorkItem == NULL);
    ASSERT(mmcData->CapabilitiesIrp == NULL);
    ASSERT(mmcData->CapabilitiesMdl == NULL);
    ASSERT(mmcData->CapabilitiesBuffer == NULL);
    ASSERT(mmcData->CapabilitiesBufferSize == 0);

    status = CdRomGetConfiguration(Fdo,
                                   &mmcData->CapabilitiesBuffer,
                                   &mmcData->CapabilitiesBufferSize,
                                   FeatureProfileList,
                                   SCSI_GET_CONFIGURATION_REQUEST_TYPE_ALL);
    if (!NT_SUCCESS(status)) {
        ASSERT(mmcData->CapabilitiesBuffer     == NULL);
        ASSERT(mmcData->CapabilitiesBufferSize == 0);
        return status;
    }
    ASSERT(mmcData->CapabilitiesBuffer     != NULL);
    ASSERT(mmcData->CapabilitiesBufferSize != 0);
    
    mmcData->CapabilitiesMdl = IoAllocateMdl(mmcData->CapabilitiesBuffer,
                                             mmcData->CapabilitiesBufferSize,
                                             FALSE, FALSE, NULL);
    if (mmcData->CapabilitiesMdl == NULL) {
        ExFreePool(mmcData->CapabilitiesBuffer);
        mmcData->CapabilitiesBufferSize = 0;
        return STATUS_INSUFFICIENT_RESOURCES;
    }

        
    mmcData->CapabilitiesIrp = IoAllocateIrp(Fdo->StackSize + 2, FALSE);
    if (mmcData->CapabilitiesIrp == NULL) {
        IoFreeMdl(mmcData->CapabilitiesMdl);
        ExFreePool(mmcData->CapabilitiesBuffer);
        mmcData->CapabilitiesBufferSize = 0;
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    mmcData->CapabilitiesWorkItem = IoAllocateWorkItem(Fdo);
    if (mmcData->CapabilitiesWorkItem == NULL) {
        IoFreeIrp(mmcData->CapabilitiesIrp);
        IoFreeMdl(mmcData->CapabilitiesMdl);
        ExFreePool(mmcData->CapabilitiesBuffer);
        mmcData->CapabilitiesBufferSize = 0;
        return STATUS_INSUFFICIENT_RESOURCES;
    }
            
    //
    // everything has been allocated, so now prepare it all....
    //

    MmBuildMdlForNonPagedPool(mmcData->CapabilitiesMdl);
    ExInitializeSListHead(&mmcData->DelayedIrps);
    KeInitializeSpinLock(&mmcData->DelayedLock);

    //
    // use the extra stack for internal bookkeeping
    //
    IoSetNextIrpStackLocation(mmcData->CapabilitiesIrp);
    irpStack = IoGetCurrentIrpStackLocation(mmcData->CapabilitiesIrp);
    irpStack->Parameters.Others.Argument1 = Fdo;
    irpStack->Parameters.Others.Argument2 = mmcData->CapabilitiesBuffer;
    irpStack->Parameters.Others.Argument3 = &(mmcData->CapabilitiesSrb);
    // arg 4 is the retry count

    //
    // set the completion event to FALSE for now
    //

    KeInitializeEvent(&mmcData->CapabilitiesEvent,
                      SynchronizationEvent, FALSE);
    return STATUS_SUCCESS;

}

Referenced by CdRomInitDevice().

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

Referenced by CdRomDeviceControlDispatch().

CdRomCompleteIrpAndStartNextPacketSafely()

static VOID CdRomCompleteIrpAndStartNextPacketSafely ( IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp  )

inlinestatic

Definition at line 407 of file cdrom.h.

{
    UCHAR uniqueAddress;
    KIRQL oldIrql = KeGetCurrentIrql();
    
    ClassAcquireRemoveLock(DeviceObject, (PIRP)&uniqueAddress);
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_CD_ROM_INCREMENT);
    
    if (oldIrql > DISPATCH_LEVEL) {
        ASSERT(!"Cannot call IoStartNextPacket at raised IRQL!");
    } else if (oldIrql < DISPATCH_LEVEL) {
        KeRaiseIrqlToDpcLevel();
    } else { //  (oldIrql == DISPATCH_LEVEL)
        NOTHING;
    }

    IoStartNextPacket(DeviceObject, FALSE);
    
    if (oldIrql > DISPATCH_LEVEL) {
        ASSERT(!"Cannot call IoStartNextPacket at raised IRQL!");
    } else if (oldIrql < DISPATCH_LEVEL) {
        KeLowerIrql(oldIrql);
    } else { //  (oldIrql == DISPATCH_LEVEL)
        NOTHING;
    }

    ClassReleaseRemoveLock(DeviceObject, (PIRP)&uniqueAddress);


    return;
}

Referenced by CdRomDeviceControlCompletion(), CdRomDeviceControlDvdSendKey(), CdRomDeviceControlDvdStartSessionReadKey(), CdromFakePartitionInfo(), CdRomSetVolumeIntermediateCompletion(), CdRomShutdownFlushCompletion(), CdRomStartIo(), CdRomSwitchModeCompletion(), CdRomUpdateCapacity(), and CdRomUpdateGeometryCompletion().

CdRomCreateDeviceObject()

NTSTATUS NTAPI CdRomCreateDeviceObject	(	IN PDRIVER_OBJECT	DriverObject,
		IN PDEVICE_OBJECT	Pdo
	)

Definition at line 253 of file cdrom.c.

{
    UCHAR ntNameBuffer[64];
    //STRING ntNameString;
    NTSTATUS status;

    PDEVICE_OBJECT lowerDevice = NULL;
    PDEVICE_OBJECT deviceObject = NULL;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = NULL;
    PCDROM_DATA cdData = NULL;
    PCDROM_DRIVER_EXTENSION driverExtension = NULL;
    ULONG deviceNumber;

    //CCHAR                   dosNameBuffer[64];
    //CCHAR                   deviceNameBuffer[64];
    //STRING                  deviceNameString;
    //STRING                  dosString;
    //UNICODE_STRING          dosUnicodeString;
    //UNICODE_STRING          unicodeString;

    PAGED_CODE();

    //
    // Claim the device. Note that any errors after this
    // will goto the generic handler, where the device will
    // be released.
    //

    lowerDevice = IoGetAttachedDeviceReference(PhysicalDeviceObject);

    status = ClassClaimDevice(lowerDevice, FALSE);

    if(!NT_SUCCESS(status)) {

        //
        // Someone already had this device - we're in trouble
        //

        ObDereferenceObject(lowerDevice);
        return status;
    }

    //
    // Create device object for this device by first getting a unique name
    // for the device and then creating it.
    //

    driverExtension = IoGetDriverObjectExtension(DriverObject,
                                                 CDROM_DRIVER_EXTENSION_ID);
    ASSERT(driverExtension != NULL);

    //
    // InterlockedCdRomCounter is biased by 1.
    //

    deviceNumber = InterlockedIncrement(&driverExtension->InterlockedCdRomCounter) - 1;
    sprintf(ntNameBuffer, "\\Device\\CdRom%d", deviceNumber);


    status = ClassCreateDeviceObject(DriverObject,
                                     ntNameBuffer,
                                     PhysicalDeviceObject,
                                     TRUE,
                                     &deviceObject);

    if (!NT_SUCCESS(status)) {
        TraceLog((CdromDebugWarning,
                    "CreateCdRomDeviceObjects: Can not create device %s\n",
                    ntNameBuffer));

        goto CreateCdRomDeviceObjectExit;
    }

    //
    // Indicate that IRPs should include MDLs.
    //

    SET_FLAG(deviceObject->Flags, DO_DIRECT_IO);

    fdoExtension = deviceObject->DeviceExtension;

    //
    // Back pointer to device object.
    //

    fdoExtension->CommonExtension.DeviceObject = deviceObject;

    //
    // This is the physical device.
    //

    fdoExtension->CommonExtension.PartitionZeroExtension = fdoExtension;

    //
    // Initialize lock count to zero. The lock count is used to
    // disable the ejection mechanism when media is mounted.
    //

    fdoExtension->LockCount = 0;

    //
    // Save system cdrom number
    //

    fdoExtension->DeviceNumber = deviceNumber;

    //
    // Set the alignment requirements for the device based on the
    // host adapter requirements
    //

    if (lowerDevice->AlignmentRequirement > deviceObject->AlignmentRequirement) {
        deviceObject->AlignmentRequirement = lowerDevice->AlignmentRequirement;
    }

    //
    // Save the device descriptors
    //

    fdoExtension->AdapterDescriptor = NULL;

    fdoExtension->DeviceDescriptor = NULL;

    //
    // Clear the SrbFlags and disable synchronous transfers
    //

    fdoExtension->SrbFlags = SRB_FLAGS_DISABLE_SYNCH_TRANSFER;

    //
    // Finally, attach to the PDO
    //

    fdoExtension->LowerPdo = PhysicalDeviceObject;

    fdoExtension->CommonExtension.LowerDeviceObject =
        IoAttachDeviceToDeviceStack(deviceObject, PhysicalDeviceObject);

    if(fdoExtension->CommonExtension.LowerDeviceObject == NULL) {

        //
        // Uh - oh, we couldn't attach
        // cleanup and return
        //

        status = STATUS_UNSUCCESSFUL;
        goto CreateCdRomDeviceObjectExit;
    }

    //
    // CdRom uses an extra stack location for synchronizing it's start io
    // routine
    //

    deviceObject->StackSize++;

    //
    // cdData is used a few times below
    //

    cdData = fdoExtension->CommonExtension.DriverData;

    //
    // For NTMS to be able to easily determine drives-drv. letter matches.
    //

    status = CdRomCreateWellKnownName( deviceObject );

    if (!NT_SUCCESS(status)) {
        TraceLog((CdromDebugWarning,
                    "CdromCreateDeviceObjects: unable to create symbolic "
                    "link for device %wZ\n", &fdoExtension->CommonExtension.DeviceName));
        TraceLog((CdromDebugWarning,
                    "CdromCreateDeviceObjects: (non-fatal error)\n"));
    }

    ClassUpdateInformationInRegistry(deviceObject, "CdRom",
                                     fdoExtension->DeviceNumber, NULL, 0);

    //
    // from above IoGetAttachedDeviceReference
    //

    ObDereferenceObject(lowerDevice);

    //
    // need to init timerlist here in case a remove occurs
    // without a start, since we check the list is empty on remove.
    //

    cdData->DelayedRetryIrp = NULL;
    cdData->DelayedRetryInterval = 0;

    //
    // need this to be initialized for RPC Phase 1 drives (rpc0)
    //

    KeInitializeMutex(&cdData->Rpc0RegionMutex, 0);
    
    //
    // The device is initialized properly - mark it as such.
    //

    CLEAR_FLAG(deviceObject->Flags, DO_DEVICE_INITIALIZING);

    return(STATUS_SUCCESS);

CreateCdRomDeviceObjectExit:

    //
    // Release the device since an error occured.
    //

    // ClassClaimDevice(PortDeviceObject,
    //                      LunInfo,
    //                      TRUE,
    //                      NULL);

    //
    // from above IoGetAttachedDeviceReference
    //

    ObDereferenceObject(lowerDevice);

    if (deviceObject != NULL) {
        IoDeleteDevice(deviceObject);
    }

    return status;

} // end CreateCdRomDeviceObject()

Referenced by CdRomAddDevice().

CdRomCreateNamedEvent()

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

CdRomCreateWellKnownName()

NTSTATUS NTAPI CdRomCreateWellKnownName

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 5620 of file cdrom.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PCDROM_DATA cdromData = commonExtension->DriverData;

    UNICODE_STRING unicodeLinkName;
    WCHAR wideLinkName[64];
    PWCHAR savedName;

    LONG cdromNumber = fdoExtension->DeviceNumber;

    NTSTATUS status;

    //
    // if already linked, assert then return
    //

    if (cdromData->WellKnownName.Buffer != NULL) {

        TraceLog((CdromDebugError,
                    "CdRomCreateWellKnownName: link already exists %p\n",
                    cdromData->WellKnownName.Buffer));
        ASSERT(FALSE);
        return STATUS_UNSUCCESSFUL;

    }

    //
    // find an unused CdRomNN to link to
    //

    do {

        swprintf(wideLinkName, L"\\DosDevices\\CdRom%d", cdromNumber);
        RtlInitUnicodeString(&unicodeLinkName, wideLinkName);
        status = IoCreateSymbolicLink(&unicodeLinkName,
                                      &(commonExtension->DeviceName));

        cdromNumber++;

    } while((status == STATUS_OBJECT_NAME_COLLISION) ||
            (status == STATUS_OBJECT_NAME_EXISTS));

    if (!NT_SUCCESS(status)) {

        TraceLog((CdromDebugWarning,
                    "CdRomCreateWellKnownName: Error %lx linking %wZ to "
                    "device %wZ\n",
                    status,
                    &unicodeLinkName,
                    &(commonExtension->DeviceName)));
        return status;

    }

    TraceLog((CdromDebugWarning,
                "CdRomCreateWellKnownName: successfully linked %wZ "
                "to device %wZ\n",
                &unicodeLinkName,
                &(commonExtension->DeviceName)));

    //
    // Save away the symbolic link name in the driver data block.  We need
    // it so we can delete the link when the device is removed.
    //

    savedName = ExAllocatePoolWithTag(PagedPool,
                                      unicodeLinkName.MaximumLength,
                                      CDROM_TAG_STRINGS);

    if (savedName == NULL) {
        IoDeleteSymbolicLink(&unicodeLinkName);
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlCopyMemory(savedName,
                  unicodeLinkName.Buffer,
                  unicodeLinkName.MaximumLength);

    RtlInitUnicodeString(&(cdromData->WellKnownName), savedName);

    //
    // the name was saved and the link created
    //

    return STATUS_SUCCESS;
}

Referenced by CdRomCreateDeviceObject().

CdRomDeAllocateMmcResources()

VOID NTAPI CdRomDeAllocateMmcResources

(

IN PDEVICE_OBJECT

Fdo

)

Definition at line 1335 of file mmc.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
    PCDROM_DATA cddata = commonExtension->DriverData;
    PCDROM_MMC_EXTENSION mmcData = &cddata->Mmc;
    //NTSTATUS status;

    if (mmcData->CapabilitiesWorkItem) {
        IoFreeWorkItem(mmcData->CapabilitiesWorkItem);
        mmcData->CapabilitiesWorkItem = NULL;
    }
    if (mmcData->CapabilitiesIrp) {
        IoFreeIrp(mmcData->CapabilitiesIrp);
        mmcData->CapabilitiesIrp = NULL;
    }
    if (mmcData->CapabilitiesMdl) {
        IoFreeMdl(mmcData->CapabilitiesMdl);
        mmcData->CapabilitiesMdl = NULL;
    }
    if (mmcData->CapabilitiesBuffer) {
        ExFreePool(mmcData->CapabilitiesBuffer);
        mmcData->CapabilitiesBuffer = NULL;
    }
    mmcData->CapabilitiesBuffer = 0;
    mmcData->IsMmc = FALSE;
    mmcData->WriteAllowed = FALSE;
    
    return;
}

Referenced by CdRomInitDevice(), and CdRomRemoveDevice().

CdRomDeleteWellKnownName()

VOID NTAPI CdRomDeleteWellKnownName

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 5732 of file cdrom.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PCDROM_DATA cdromData = commonExtension->DriverData;

    if(cdromData->WellKnownName.Buffer != NULL) {

        IoDeleteSymbolicLink(&(cdromData->WellKnownName));
        ExFreePool(cdromData->WellKnownName.Buffer);
        cdromData->WellKnownName.Buffer = NULL;
        cdromData->WellKnownName.Length = 0;
        cdromData->WellKnownName.MaximumLength = 0;

    }
    return;
}

Referenced by CdRomRemoveDevice().

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(DISK_GEOMETRY);
            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;
}

Referenced by CdRomSetVolumeIntermediateCompletion().

CdRomDeviceControlDispatch()

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

Definition at line 45 of file ioctl.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION  fdoExtension = DeviceObject->DeviceExtension;
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;

    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PIO_STACK_LOCATION nextStack;
    PCDROM_DATA        cdData = (PCDROM_DATA)(commonExtension->DriverData);

    //BOOLEAN            use6Byte = TEST_FLAG(cdData->XAFlags, XA_USE_6_BYTE);
    SCSI_REQUEST_BLOCK srb;
    PCDB cdb = (PCDB)srb.Cdb;
    //PVOID outputBuffer;
    //ULONG bytesTransferred = 0;
    NTSTATUS status;
    //NTSTATUS status2;
    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;

    TraceLog((CdromDebugTrace,
                "CdRomDeviceControl: Ioctl Code = %lx, 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);

        TraceLog((CdromDebugTrace,
                    "CdRomDeviceControl: Class Code - new ioctl code is %lx\n",
                    ioctlCode));

        irpStack->Parameters.DeviceIoControl.IoControlCode = ioctlCode;

    }

    switch (ioctlCode) {

    case IOCTL_STORAGE_GET_MEDIA_TYPES_EX: {

        PGET_MEDIA_TYPES  mediaTypes = Irp->AssociatedIrp.SystemBuffer;
        PDEVICE_MEDIA_INFO mediaInfo = &mediaTypes->MediaInfo[0];
        ULONG sizeNeeded;

        sizeNeeded = sizeof(GET_MEDIA_TYPES);
        
        //
        // IsMmc is static...
        //

        if (cdData->Mmc.IsMmc) {
            sizeNeeded += sizeof(DEVICE_MEDIA_INFO) * 1; // return two media types
        }

        //
        // Ensure that buffer is large enough.
        //

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

            //
            // Buffer too small.
            //

            Irp->IoStatus.Information = sizeNeeded;
            status = STATUS_BUFFER_TOO_SMALL;
            break;
        }
        
        RtlZeroMemory(Irp->AssociatedIrp.SystemBuffer, sizeNeeded);

        //
        // ISSUE-2000/5/11-henrygab - need to update GET_MEDIA_TYPES_EX
        //

        mediaTypes->DeviceType = CdRomGetDeviceType(DeviceObject);

        mediaTypes->MediaInfoCount = 1;
        mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaType = CD_ROM;
        mediaInfo->DeviceSpecific.RemovableDiskInfo.NumberMediaSides = 1;
        mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics = MEDIA_READ_ONLY;
        mediaInfo->DeviceSpecific.RemovableDiskInfo.Cylinders.QuadPart = fdoExtension->DiskGeometry.Cylinders.QuadPart;
        mediaInfo->DeviceSpecific.RemovableDiskInfo.TracksPerCylinder = fdoExtension->DiskGeometry.TracksPerCylinder;
        mediaInfo->DeviceSpecific.RemovableDiskInfo.SectorsPerTrack = fdoExtension->DiskGeometry.SectorsPerTrack;
        mediaInfo->DeviceSpecific.RemovableDiskInfo.BytesPerSector = fdoExtension->DiskGeometry.BytesPerSector;

        if (cdData->Mmc.IsMmc) {
            
            //
            // also report a removable disk
            //
            mediaTypes->MediaInfoCount += 1;
            
            mediaInfo++;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaType = RemovableMedia;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.NumberMediaSides = 1;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics = MEDIA_READ_WRITE;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.Cylinders.QuadPart = fdoExtension->DiskGeometry.Cylinders.QuadPart;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.TracksPerCylinder = fdoExtension->DiskGeometry.TracksPerCylinder;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.SectorsPerTrack = fdoExtension->DiskGeometry.SectorsPerTrack;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.BytesPerSector = fdoExtension->DiskGeometry.BytesPerSector;
            mediaInfo--;
        
        }

        //
        // Status will either be success, if media is present, or no media.
        // It would be optimal to base from density code and medium type, but not all devices
        // have values for these fields.
        //

        //
        // Send a TUR to determine if media is present.
        //

        srb.CdbLength = 6;
        cdb = (PCDB)srb.Cdb;
        cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;

        //
        // Set timeout value.
        //

        srb.TimeOutValue = fdoExtension->TimeOutValue;

        status = ClassSendSrbSynchronous(DeviceObject,
                                         &srb,
                                         NULL,
                                         0,
                                         FALSE);


        TraceLog((CdromDebugWarning,
                   "CdRomDeviceControl: GET_MEDIA_TYPES status of TUR - %lx\n",
                   status));

        if (NT_SUCCESS(status)) {

            //
            // set the disk's media as current if we can write to it.
            //

            if (cdData->Mmc.IsMmc && cdData->Mmc.WriteAllowed) {

                mediaInfo++;
                SET_FLAG(mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics,
                         MEDIA_CURRENTLY_MOUNTED);
                mediaInfo--;


            } else {

                SET_FLAG(mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics,
                         MEDIA_CURRENTLY_MOUNTED);

            }

        }

        Irp->IoStatus.Information = sizeNeeded;
        status = STATUS_SUCCESS;
        break;
    }


    case IOCTL_CDROM_RAW_READ: {

        LARGE_INTEGER  startingOffset;
        ULONGLONG      transferBytes;
        ULONGLONG      endOffset;
        ULONGLONG      mdlBytes;
        //ULONG          startingSector;
        PRAW_READ_INFO rawReadInfo = (PRAW_READ_INFO)irpStack->Parameters.DeviceIoControl.Type3InputBuffer;

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

        if (TEST_FLAG(cdData->XAFlags, XA_NOT_SUPPORTED)) {
            TraceLog((CdromDebugWarning,
                        "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. Save the userbuffer in the 
            // Type3InputBuffer so we can reduce the number of code paths.
            //

            irpStack->Parameters.DeviceIoControl.Type3InputBuffer =
                Irp->AssociatedIrp.SystemBuffer;

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

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

            if (rawReadInfo == NULL) {

                TraceLog((CdromDebugWarning,
                            "CdRomDeviceControl: Invalid I/O parameters for "
                            "XA Read (No extent info\n"));
                status = STATUS_INVALID_PARAMETER;
                break;

            }

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

                TraceLog((CdromDebugWarning,
                            "CdRomDeviceControl: Invalid I/O parameters for "
                            "XA Read (Invalid info buffer\n"));
                status = STATUS_INVALID_PARAMETER;
                break;

            }
        }

        //
        // if they don't request any data, just fail the request
        //

        if (rawReadInfo->SectorCount == 0) {

            status = STATUS_INVALID_PARAMETER;
            break;

        }

        startingOffset.QuadPart = rawReadInfo->DiskOffset.QuadPart;
        /* startingSector = (ULONG)(rawReadInfo->DiskOffset.QuadPart >>
                                 fdoExtension->SectorShift); */
        transferBytes = (ULONGLONG)rawReadInfo->SectorCount * RAW_SECTOR_SIZE;
        
        endOffset = (ULONGLONG)rawReadInfo->SectorCount * COOKED_SECTOR_SIZE;
        endOffset += startingOffset.QuadPart;

        //
        // check for overflows....
        //
        
        if (transferBytes < (ULONGLONG)(rawReadInfo->SectorCount)) {
            TraceLog((CdromDebugWarning,
                        "CdRomDeviceControl: Invalid I/O parameters for XA "
                        "Read (TransferBytes Overflow)\n"));
            status = STATUS_INVALID_PARAMETER;
            break;
        }
        if (endOffset < (ULONGLONG)startingOffset.QuadPart) {
            TraceLog((CdromDebugWarning,
                        "CdRomDeviceControl: Invalid I/O parameters for XA "
                        "Read (EndingOffset Overflow)\n"));
            status = STATUS_INVALID_PARAMETER;
            break;
        }
        if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
            transferBytes) {
            TraceLog((CdromDebugWarning,
                        "CdRomDeviceControl: Invalid I/O parameters for XA "
                        "Read (Bad buffer size)\n"));
            status = STATUS_INVALID_PARAMETER;
            break;
        }
        if (endOffset > (ULONGLONG)commonExtension->PartitionLength.QuadPart) {
            TraceLog((CdromDebugWarning,
                        "CdRomDeviceControl: Invalid I/O parameters for XA "
                        "Read (Request Out of Bounds)\n"));
            status = STATUS_INVALID_PARAMETER;
            break;
        }

        //
        // cannot validate the MdlAddress, since it is not included in any
        // other location per the DDK and file system calls.
        //

        //
        // validate the mdl describes at least the number of bytes
        // requested from us.
        //

        mdlBytes = (ULONGLONG)MmGetMdlByteCount(Irp->MdlAddress);
        if (mdlBytes < transferBytes) {
            TraceLog((CdromDebugWarning,
                        "CdRomDeviceControl: Invalid MDL %s, Irp %p\n",
                        "size (5)", Irp));
            status = STATUS_INVALID_PARAMETER;
            break;
        }

        //
        // HACKHACK - REF #0001
        // The retry count will be in this irp's IRP_MN function,
        // as the new irp was freed, and we therefore cannot use
        // this irp's next stack location for this function.
        // This may be a good location to store this info for
        // when we remove RAW_READ (mode switching), as we will
        // no longer have the nextIrpStackLocation to play with
        // when that occurs
        //
        // once XA_READ is removed, then this hack can also be
        // removed.
        //
        irpStack->MinorFunction = MAXIMUM_RETRIES; // HACKHACK - REF #0001

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

        return STATUS_PENDING;
    }

    case IOCTL_DISK_GET_DRIVE_GEOMETRY_EX:
    case IOCTL_CDROM_GET_DRIVE_GEOMETRY_EX: {
        TraceLog((CdromDebugTrace,
                    "CdRomDeviceControl: Get drive geometryEx\n"));
        if ( irpStack->Parameters.DeviceIoControl.OutputBufferLength <
             FIELD_OFFSET(DISK_GEOMETRY_EX, Data)) {
            status = STATUS_BUFFER_TOO_SMALL;
            Irp->IoStatus.Information = FIELD_OFFSET(DISK_GEOMETRY_EX, Data);
            break;
        }
        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject, Irp, NULL, NULL);
        return STATUS_PENDING;
    }

    case IOCTL_DISK_GET_DRIVE_GEOMETRY:
    case IOCTL_CDROM_GET_DRIVE_GEOMETRY: {

        TraceLog((CdromDebugTrace,
                    "CdRomDeviceControl: Get drive geometry\n"));

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

            status = STATUS_BUFFER_TOO_SMALL;
            Irp->IoStatus.Information = sizeof(DISK_GEOMETRY);
            break;
        }

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

        return STATUS_PENDING;
    }

    case IOCTL_CDROM_READ_TOC_EX: {

        PCDROM_READ_TOC_EX inputBuffer;
        
        if (CdRomIsPlayActive(DeviceObject)) {
            status = STATUS_DEVICE_BUSY;
            break;
        }

        if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
            sizeof(CDROM_READ_TOC_EX)) {
            status = STATUS_INFO_LENGTH_MISMATCH;
            break;
        }

        if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
            MINIMUM_CDROM_READ_TOC_EX_SIZE) {
            status = STATUS_BUFFER_TOO_SMALL;
            Irp->IoStatus.Information = MINIMUM_CDROM_READ_TOC_EX_SIZE;
            break;
        }

        if (irpStack->Parameters.Read.Length > ((USHORT)-1)) {
            status = STATUS_INVALID_PARAMETER;
            break;
        }

        inputBuffer = Irp->AssociatedIrp.SystemBuffer;

        if ((inputBuffer->Reserved1 != 0) ||
            (inputBuffer->Reserved2 != 0) ||
            (inputBuffer->Reserved3 != 0)) {
            status = STATUS_INVALID_PARAMETER;
            break;
        }

        //
        // NOTE: when adding new formats, ensure that first two bytes
        //       specify the amount of additional data available.
        //

        if ((inputBuffer->Format == CDROM_READ_TOC_EX_FORMAT_TOC     ) ||
            (inputBuffer->Format == CDROM_READ_TOC_EX_FORMAT_FULL_TOC) ||
            (inputBuffer->Format == CDROM_READ_TOC_EX_FORMAT_CDTEXT  )) {
            
            // SessionTrack field is used

        } else
        if ((inputBuffer->Format == CDROM_READ_TOC_EX_FORMAT_SESSION) ||
            (inputBuffer->Format == CDROM_READ_TOC_EX_FORMAT_PMA)     ||
            (inputBuffer->Format == CDROM_READ_TOC_EX_FORMAT_ATIP)) {
            
            // SessionTrack field is reserved
            
            if (inputBuffer->SessionTrack != 0) {
                status = STATUS_INVALID_PARAMETER;
                break;
            }
            
        } else {
            status = STATUS_INVALID_PARAMETER;
            break;
        }

        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject, Irp, NULL, NULL);
        return STATUS_PENDING;
    }

    case IOCTL_CDROM_GET_LAST_SESSION: {

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

        if (CdRomIsPlayActive(DeviceObject)) {
            status = STATUS_DEVICE_BUSY;
            break;
        }

        //
        // Make sure the caller is requesting enough data to make this worth
        // our while.
        //

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

            //
            // they didn't request the entire TOC -- use _EX version
            // for partial transfers and such.
            //

            status = STATUS_BUFFER_TOO_SMALL;
            Irp->IoStatus.Information = sizeof(CDROM_TOC_SESSION_DATA);
            break;
        }

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

        return STATUS_PENDING;
    }

    case IOCTL_CDROM_READ_TOC:  {

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

        if (CdRomIsPlayActive(DeviceObject)) {
            status = STATUS_DEVICE_BUSY;
            break;
        }

        //
        // Make sure the caller is requesting enough data to make this worth
        // our while.
        //

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

            //
            // they didn't request the entire TOC -- use _EX version
            // for partial transfers and such.
            //

            status = STATUS_BUFFER_TOO_SMALL;
            Irp->IoStatus.Information = sizeof(CDROM_TOC);
            break;
        }

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

        return STATUS_PENDING;
    }

    case IOCTL_CDROM_PLAY_AUDIO_MSF: {

        //
        // Play Audio MSF
        //

        TraceLog((CdromDebugTrace,
                    "CdRomDeviceControl: Play audio MSF\n"));

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

            //
            // Indicate unsuccessful status.
            //

            status = STATUS_INFO_LENGTH_MISMATCH;
            break;
        }

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

        return STATUS_PENDING;
    }

    case IOCTL_CDROM_SEEK_AUDIO_MSF: {


        //
        // Seek Audio MSF
        //

        TraceLog((CdromDebugTrace,
                    "CdRomDeviceControl: Seek audio MSF\n"));

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

            //
            // Indicate unsuccessful status.
            //

            status = STATUS_INFO_LENGTH_MISMATCH;
            break;
        }
        
        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject, Irp, NULL, NULL);
        return STATUS_PENDING;

    }

    case IOCTL_CDROM_PAUSE_AUDIO: {

        //
        // Pause audio
        //

        TraceLog((CdromDebugTrace,
                    "CdRomDeviceControl: Pause audio\n"));

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

        return STATUS_PENDING;

        break;
    }

    case IOCTL_CDROM_RESUME_AUDIO: {

        //
        // Resume audio
        //

        TraceLog((CdromDebugTrace,
                    "CdRomDeviceControl: Resume audio\n"));

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

        return STATUS_PENDING;
    }

    case IOCTL_CDROM_READ_Q_CHANNEL: {

        PCDROM_SUB_Q_DATA_FORMAT inputBuffer =
                         Irp->AssociatedIrp.SystemBuffer;

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

            status = STATUS_INFO_LENGTH_MISMATCH;
            break;
        }

        //
        // check for all valid types of request
        //

        if (inputBuffer->Format != IOCTL_CDROM_CURRENT_POSITION &&
            inputBuffer->Format != IOCTL_CDROM_MEDIA_CATALOG &&
            inputBuffer->Format != IOCTL_CDROM_TRACK_ISRC ) {
            status = STATUS_INVALID_PARAMETER;
            Irp->IoStatus.Information = 0;
            break;
        }

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

        return STATUS_PENDING;
    }

    case IOCTL_CDROM_GET_CONTROL: {

        TraceLog((CdromDebugTrace,
                    "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 = sizeof(CDROM_AUDIO_CONTROL);
            break;

        }

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

        return STATUS_PENDING;
    }

    case IOCTL_CDROM_GET_VOLUME: {

        TraceLog((CdromDebugTrace,
                    "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 = sizeof(VOLUME_CONTROL);
            break;

        }

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

        return STATUS_PENDING;
    }

    case IOCTL_CDROM_SET_VOLUME: {

        TraceLog((CdromDebugTrace,
                    "CdRomDeviceControl: Set volume control\n"));

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

            //
            // Indicate unsuccessful status.
            //

            status = STATUS_INFO_LENGTH_MISMATCH;
            break;

        }

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

        return STATUS_PENDING;
    }

    case IOCTL_CDROM_STOP_AUDIO: {

        //
        // Stop play.
        //

        TraceLog((CdromDebugTrace,
                    "CdRomDeviceControl: Stop audio\n"));

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

        return STATUS_PENDING;
    }

    case IOCTL_STORAGE_CHECK_VERIFY:
    case IOCTL_DISK_CHECK_VERIFY:
    case IOCTL_CDROM_CHECK_VERIFY: {

        TraceLog((CdromDebugTrace,
                    "CdRomDeviceControl: [%p] Check Verify\n", Irp));

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

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

           status = STATUS_BUFFER_TOO_SMALL;
           Irp->IoStatus.Information = sizeof(ULONG);
           break;
        }

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

        return STATUS_PENDING;
    }

    case IOCTL_DVD_READ_STRUCTURE: {

        TraceLog((CdromDebugTrace,
                    "DvdDeviceControl: [%p] IOCTL_DVD_READ_STRUCTURE\n", Irp));

        if (cdData->DvdRpc0Device && cdData->DvdRpc0LicenseFailure) {
            TraceLog((CdromDebugWarning,
                        "DvdDeviceControl: License Failure\n"));
            status = STATUS_COPY_PROTECTION_FAILURE;
            break;
        }

        if (cdData->DvdRpc0Device && cdData->Rpc0RetryRegistryCallback) {
            //
            // if currently in-progress, this will just return.
            // prevents looping by doing that interlockedExchange()
            //
            TraceLog((CdromDebugWarning,
                        "DvdDeviceControl: PickRegion() from "
                        "READ_STRUCTURE\n"));
            CdRomPickDvdRegion(DeviceObject);
        }


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

            TraceLog((CdromDebugWarning,
                        "DvdDeviceControl - READ_STRUCTURE: input buffer "
                        "length too small (was %d should be %d)\n",
                        irpStack->Parameters.DeviceIoControl.InputBufferLength,
                        sizeof(DVD_READ_STRUCTURE)));
            status = STATUS_INVALID_PARAMETER;
            break;
        }

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

            TraceLog((CdromDebugWarning,
                        "DvdDeviceControl - READ_STRUCTURE: output buffer "
                        "cannot hold header information\n"));
            status = STATUS_BUFFER_TOO_SMALL;
            Irp->IoStatus.Information = sizeof(READ_DVD_STRUCTURES_HEADER);            
            break;
        }

        if(irpStack->Parameters.DeviceIoControl.OutputBufferLength >
           MAXUSHORT) {

            //
            // key length must fit in two bytes
            //
            TraceLog((CdromDebugWarning,
                        "DvdDeviceControl - READ_STRUCTURE: output buffer "
                        "too large\n"));
            status = STATUS_INVALID_PARAMETER;
            break;
        }

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

        return STATUS_PENDING;
    }

    case IOCTL_DVD_START_SESSION: {

        TraceLog((CdromDebugTrace,
                    "DvdDeviceControl: [%p] IOCTL_DVD_START_SESSION\n", Irp));

        if (cdData->DvdRpc0Device && cdData->DvdRpc0LicenseFailure) {
            TraceLog((CdromDebugWarning,
                        "DvdDeviceControl: License Failure\n"));
            status = STATUS_COPY_PROTECTION_FAILURE;
            break;
        }

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

            TraceLog((CdromDebugWarning,
                        "DvdDeviceControl: DVD_START_SESSION - output "
                        "buffer too small\n"));
            status = STATUS_BUFFER_TOO_SMALL;
            Irp->IoStatus.Information = sizeof(DVD_SESSION_ID);
            break;
        }

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

        return STATUS_PENDING;
    }

    case IOCTL_DVD_SEND_KEY:
    case IOCTL_DVD_SEND_KEY2: {

        PDVD_COPY_PROTECT_KEY key = Irp->AssociatedIrp.SystemBuffer;
        //ULONG keyLength;

        TraceLog((CdromDebugTrace,
                    "DvdDeviceControl: [%p] IOCTL_DVD_SEND_KEY\n", Irp));

        if (cdData->DvdRpc0Device && cdData->DvdRpc0LicenseFailure) {
            TraceLog((CdromDebugWarning,
                        "DvdDeviceControl: License Failure\n"));
            status = STATUS_COPY_PROTECTION_FAILURE;
            break;
        }

        if((irpStack->Parameters.DeviceIoControl.InputBufferLength <
            sizeof(DVD_COPY_PROTECT_KEY)) ||
           (irpStack->Parameters.DeviceIoControl.InputBufferLength !=
            key->KeyLength)) {

            //
            // Key is too small to have a header or the key length doesn't
            // match the input buffer length.  Key must be invalid
            //

            TraceLog((CdromDebugWarning,
                        "DvdDeviceControl: [%p] IOCTL_DVD_SEND_KEY - "
                        "key is too small or does not match KeyLength\n",
                        Irp));
            status = STATUS_INVALID_PARAMETER;
            break;
        }

        //
        // allow only certain key type (non-destructive) to go through
        // IOCTL_DVD_SEND_KEY (which only requires READ access to the device
        //
        if (ioctlCode == IOCTL_DVD_SEND_KEY) {

            if ((key->KeyType != DvdChallengeKey) &&
                (key->KeyType != DvdBusKey2) &&
                (key->KeyType != DvdInvalidateAGID)) {

                status = STATUS_INVALID_PARAMETER;
                break;
            }
        }

        if (cdData->DvdRpc0Device) {

            if (key->KeyType == DvdSetRpcKey) {

                PDVD_SET_RPC_KEY rpcKey = (PDVD_SET_RPC_KEY) key->KeyData;

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

                    status = STATUS_INVALID_PARAMETER;
                    break;
                }

                //
                // we have a request to set region code
                // on a RPC0 device which doesn't support
                // region coding.
                //
                // we have to fake it.
                //

                KeWaitForMutexObject(
                    &cdData->Rpc0RegionMutex,
                    UserRequest,
                    KernelMode,
                    FALSE,
                    NULL
                    );

                if (cdData->DvdRpc0Device && cdData->Rpc0RetryRegistryCallback) {
                    //
                    // if currently in-progress, this will just return.
                    // prevents looping by doing that interlockedExchange()
                    //
                    TraceLog((CdromDebugWarning,
                                "DvdDeviceControl: PickRegion() from "
                                "SEND_KEY\n"));
                    CdRomPickDvdRegion(DeviceObject);
                }

                if (cdData->Rpc0SystemRegion == rpcKey->PreferredDriveRegionCode) {

                    //
                    // nothing to change
                    //
                    TraceLog((CdromDebugWarning,
                                "DvdDeviceControl (%p) => not changing "
                                "regions -- requesting current region\n",
                                DeviceObject));
                    status = STATUS_SUCCESS;

                } else if (cdData->Rpc0SystemRegionResetCount == 0) {

                    //
                    // not allowed to change it again
                    //

                    TraceLog((CdromDebugWarning,
                                "DvdDeviceControl (%p) => no more region "
                                "changes are allowed for this device\n",
                                DeviceObject));
                    status = STATUS_CSS_RESETS_EXHAUSTED;

                } else {

                    //ULONG i;
                    UCHAR mask;
                    ULONG bufferLen;
                    PDVD_READ_STRUCTURE dvdReadStructure;
                    PDVD_COPYRIGHT_DESCRIPTOR dvdCopyRight;
                    IO_STATUS_BLOCK ioStatus;
                    UCHAR mediaRegionData;

                    mask = ~rpcKey->PreferredDriveRegionCode;

                    if (CountOfSetBitsUChar(mask) != 1) {

                        status = STATUS_INVALID_DEVICE_REQUEST;
                        break;
                    }

                    //
                    // this test will always be TRUE except during initial
                    // automatic selection of the first region.
                    //

                    if (cdData->Rpc0SystemRegion != 0xff) {

                        //
                        // make sure we have a media in the drive with the same
                        // region code if the drive is already has a region set
                        //

                        TraceLog((CdromDebugTrace,
                                    "DvdDeviceControl (%p) => Checking "
                                    "media region\n",
                                    DeviceObject));

                        bufferLen = max(sizeof(DVD_DESCRIPTOR_HEADER) +
                                            sizeof(DVD_COPYRIGHT_DESCRIPTOR),
                                        sizeof(DVD_READ_STRUCTURE)
                                        );

                        dvdReadStructure = (PDVD_READ_STRUCTURE)
                            ExAllocatePoolWithTag(PagedPool,
                                                  bufferLen,
                                                  DVD_TAG_RPC2_CHECK);

                        if (dvdReadStructure == NULL) {
                            status = STATUS_INSUFFICIENT_RESOURCES;
                            KeReleaseMutex(&cdData->Rpc0RegionMutex,FALSE);
                            break;
                        }

                        dvdCopyRight = (PDVD_COPYRIGHT_DESCRIPTOR)
                            ((PDVD_DESCRIPTOR_HEADER) dvdReadStructure)->Data;

                        //
                        // check to see if we have a DVD device
                        //

                        RtlZeroMemory (dvdReadStructure, bufferLen);
                        dvdReadStructure->Format = DvdCopyrightDescriptor;

                        //
                        // Build a request for READ_KEY
                        //
                        ClassSendDeviceIoControlSynchronous(
                            IOCTL_DVD_READ_STRUCTURE,
                            DeviceObject,
                            dvdReadStructure,
                            sizeof(DVD_READ_STRUCTURE),
                            sizeof(DVD_DESCRIPTOR_HEADER) +
                                sizeof(DVD_COPYRIGHT_DESCRIPTOR),
                            FALSE,
                            &ioStatus);

                        //
                        // this is just to prevent bugs from creeping in
                        // if status is not set later in development
                        //

                        status = ioStatus.Status;

                        //
                        // handle errors
                        //

                        if (!NT_SUCCESS(status)) {
                            KeReleaseMutex(&cdData->Rpc0RegionMutex,FALSE);
                            ExFreePool(dvdReadStructure);
                            status = STATUS_INVALID_DEVICE_REQUEST;
                            break;
                        }

                        //
                        // save the mediaRegionData before freeing the
                        // allocated memory
                        //

                        mediaRegionData =
                            dvdCopyRight->RegionManagementInformation;
                        ExFreePool(dvdReadStructure);

                        TraceLog((CdromDebugWarning,
                                    "DvdDeviceControl (%p) => new mask is %x"
                                    " MediaRegionData is %x\n", DeviceObject,
                                    rpcKey->PreferredDriveRegionCode,
                                    mediaRegionData));

                        //
                        // the media region must match the requested region
                        // for RPC0 drives for initial region selection
                        //

                        if (((UCHAR)~(mediaRegionData | rpcKey->PreferredDriveRegionCode)) == 0) {
                            KeReleaseMutex(&cdData->Rpc0RegionMutex,FALSE);
                            status = STATUS_CSS_REGION_MISMATCH;
                            break;
                        }

                    }

                    //
                    // now try to set the region
                    //

                    TraceLog((CdromDebugTrace,
                                "DvdDeviceControl (%p) => Soft-Setting "
                                "region of RPC1 device to %x\n",
                                DeviceObject,
                                rpcKey->PreferredDriveRegionCode
                                ));

                    status = CdRomSetRpc0Settings(DeviceObject,
                                                  rpcKey->PreferredDriveRegionCode);

                    if (!NT_SUCCESS(status)) {
                        TraceLog((CdromDebugWarning,
                                    "DvdDeviceControl (%p) => Could not "
                                    "set region code (%x)\n",
                                    DeviceObject, status
                                    ));
                    } else {

                        TraceLog((CdromDebugTrace,
                                    "DvdDeviceControl (%p) => New region set "
                                    " for RPC1 drive\n", DeviceObject));

                        //
                        // if it worked, our extension is already updated.
                        // release the mutex
                        //

                        DebugPrint ((4, "DvdDeviceControl (%p) => DVD current "
                                     "region bitmap  0x%x\n", DeviceObject,
                                     cdData->Rpc0SystemRegion));
                        DebugPrint ((4, "DvdDeviceControl (%p) => DVD region "
                                     " reset Count     0x%x\n", DeviceObject,
                                     cdData->Rpc0SystemRegionResetCount));
                    }

                }

                KeReleaseMutex(&cdData->Rpc0RegionMutex,FALSE);
                break;
            } // end of key->KeyType == DvdSetRpcKey
        } // end of Rpc0Device hacks

        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject, Irp, NULL, NULL);
        return STATUS_PENDING;
    }

    case IOCTL_DVD_READ_KEY: {

        PDVD_COPY_PROTECT_KEY keyParameters = Irp->AssociatedIrp.SystemBuffer;
        ULONG keyLength;

        TraceLog((CdromDebugTrace,
                    "DvdDeviceControl: [%p] IOCTL_DVD_READ_KEY\n", Irp));

        if (cdData->DvdRpc0Device && cdData->DvdRpc0LicenseFailure) {
            TraceLog((CdromDebugWarning,
                        "DvdDeviceControl: License Failure\n"));
            status = STATUS_COPY_PROTECTION_FAILURE;
            break;
        }

        if (cdData->DvdRpc0Device && cdData->Rpc0RetryRegistryCallback) {
            TraceLog((CdromDebugWarning,
                        "DvdDeviceControl: PickRegion() from READ_KEY\n"));
            CdRomPickDvdRegion(DeviceObject);
        }


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

            TraceLog((CdromDebugWarning,
                        "DvdDeviceControl: EstablishDriveKey - challenge "
                        "key buffer too small\n"));

            status = STATUS_INVALID_PARAMETER;
            break;

        }


        switch(keyParameters->KeyType) {

            case DvdChallengeKey:
                keyLength = DVD_CHALLENGE_KEY_LENGTH;
                break;

            case DvdBusKey1:
            case DvdBusKey2:

                keyLength = DVD_BUS_KEY_LENGTH;
                break;

            case DvdTitleKey:
                keyLength = DVD_TITLE_KEY_LENGTH;
                break;

            case DvdAsf:
                keyLength = DVD_ASF_LENGTH;
                break;

            case DvdDiskKey:
                keyLength = DVD_DISK_KEY_LENGTH;
                break;

            case DvdGetRpcKey:
                keyLength = DVD_RPC_KEY_LENGTH;
                break;

            default:
                keyLength = sizeof(DVD_COPY_PROTECT_KEY);
                break;
        }

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

            TraceLog((CdromDebugWarning,
                        "DvdDeviceControl: EstablishDriveKey - output "
                        "buffer too small\n"));
            status = STATUS_BUFFER_TOO_SMALL;
            Irp->IoStatus.Information = keyLength;
            break;
        }

        if (keyParameters->KeyType == DvdGetRpcKey) {

            CdRomPickDvdRegion(DeviceObject);
        }

        if ((keyParameters->KeyType == DvdGetRpcKey) &&
            (cdData->DvdRpc0Device)) {

            PDVD_RPC_KEY rpcKey;
            rpcKey = (PDVD_RPC_KEY)keyParameters->KeyData;
            RtlZeroMemory (rpcKey, sizeof (*rpcKey));

            KeWaitForMutexObject(
                &cdData->Rpc0RegionMutex,
                UserRequest,
                KernelMode,
                FALSE,
                NULL
                );

            //
            // make up the data
            //
            rpcKey->UserResetsAvailable = cdData->Rpc0SystemRegionResetCount;
            rpcKey->ManufacturerResetsAvailable = 0;
            if (cdData->Rpc0SystemRegion == 0xff) {
                rpcKey->TypeCode = 0;
            } else {
                rpcKey->TypeCode = 1;
            }
            rpcKey->RegionMask = (UCHAR) cdData->Rpc0SystemRegion;
            rpcKey->RpcScheme = 1;

            KeReleaseMutex(
                &cdData->Rpc0RegionMutex,
                FALSE
                );

            Irp->IoStatus.Information = DVD_RPC_KEY_LENGTH;
            status = STATUS_SUCCESS;
            break;

        } else if (keyParameters->KeyType == DvdDiskKey) {

            PDVD_COPY_PROTECT_KEY keyHeader;
            PDVD_READ_STRUCTURE readStructureRequest;

            //
            // Special case - build a request to get the dvd structure
            // so we can get the disk key.
            //

            //
            // save the key header so we can restore the interesting
            // parts later
            //

            keyHeader = ExAllocatePoolWithTag(NonPagedPool,
                                              sizeof(DVD_COPY_PROTECT_KEY),
                                              DVD_TAG_READ_KEY);

            if(keyHeader == NULL) {

                //
                // Can't save the context so return an error
                //

                TraceLog((CdromDebugWarning,
                            "DvdDeviceControl - READ_KEY: unable to "
                            "allocate context\n"));
                status = STATUS_INSUFFICIENT_RESOURCES;
                break;
            }

            RtlCopyMemory(keyHeader,
                          Irp->AssociatedIrp.SystemBuffer,
                          sizeof(DVD_COPY_PROTECT_KEY));

            IoCopyCurrentIrpStackLocationToNext(Irp);

            nextStack = IoGetNextIrpStackLocation(Irp);

            nextStack->Parameters.DeviceIoControl.IoControlCode =
                IOCTL_DVD_READ_STRUCTURE;

            readStructureRequest = Irp->AssociatedIrp.SystemBuffer;
            readStructureRequest->Format = DvdDiskKeyDescriptor;
            readStructureRequest->BlockByteOffset.QuadPart = 0;
            readStructureRequest->LayerNumber = 0;
            readStructureRequest->SessionId = keyHeader->SessionId;

            nextStack->Parameters.DeviceIoControl.InputBufferLength =
                sizeof(DVD_READ_STRUCTURE);

            nextStack->Parameters.DeviceIoControl.OutputBufferLength =
                sizeof(READ_DVD_STRUCTURES_HEADER) + sizeof(DVD_DISK_KEY_DESCRIPTOR);

            IoSetCompletionRoutine(Irp,
                                   CdRomDvdReadDiskKeyCompletion,
                                   (PVOID) keyHeader,
                                   TRUE,
                                   TRUE,
                                   TRUE);

            {
                UCHAR uniqueAddress;
                ClassAcquireRemoveLock(DeviceObject, (PIRP)&uniqueAddress);
                ClassReleaseRemoveLock(DeviceObject, Irp);

                IoMarkIrpPending(Irp);
                IoCallDriver(commonExtension->DeviceObject, Irp);
                status = STATUS_PENDING;

                ClassReleaseRemoveLock(DeviceObject, (PIRP)&uniqueAddress);
            }

            return STATUS_PENDING;

        } else {

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

        }
        return STATUS_PENDING;
    }

    case IOCTL_DVD_END_SESSION: {

        PDVD_SESSION_ID sessionId = Irp->AssociatedIrp.SystemBuffer;

        TraceLog((CdromDebugTrace,
                    "DvdDeviceControl: [%p] END_SESSION\n", Irp));

        if (cdData->DvdRpc0Device && cdData->DvdRpc0LicenseFailure) {
            TraceLog((CdromDebugWarning,
                        "DvdDeviceControl: License Failure\n"));
            status = STATUS_COPY_PROTECTION_FAILURE;
            break;
        }

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

            TraceLog((CdromDebugWarning,
                        "DvdDeviceControl: EndSession - input buffer too "
                        "small\n"));
            status = STATUS_INVALID_PARAMETER;
            break;
        }

        IoMarkIrpPending(Irp);

        if(*sessionId == DVD_END_ALL_SESSIONS) {

            status = CdRomDvdEndAllSessionsCompletion(DeviceObject, Irp, NULL);

            if(status == STATUS_SUCCESS) {

                //
                // Just complete the request - it was never issued to the
                // lower device
                //

                break;

            } else {

                return STATUS_PENDING;

            }
        }

        IoStartPacket(DeviceObject, Irp, NULL, NULL);

        return STATUS_PENDING;
    }

    case IOCTL_DVD_GET_REGION: {

        PDVD_COPY_PROTECT_KEY copyProtectKey;
        ULONG keyLength;
        IO_STATUS_BLOCK ioStatus;
        PDVD_DESCRIPTOR_HEADER dvdHeader;
        PDVD_COPYRIGHT_DESCRIPTOR copyRightDescriptor;
        PDVD_REGION dvdRegion;
        PDVD_READ_STRUCTURE readStructure;
        PDVD_RPC_KEY rpcKey;

        TraceLog((CdromDebugTrace,
                    "DvdDeviceControl: [%p] IOCTL_DVD_GET_REGION\n", Irp));

        if (cdData->DvdRpc0Device && cdData->DvdRpc0LicenseFailure) {
            TraceLog((CdromDebugWarning,
                        "DvdDeviceControl: License Failure\n"));
            status = STATUS_COPY_PROTECTION_FAILURE;
            break;
        }

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

            TraceLog((CdromDebugWarning,
                        "DvdDeviceControl: output buffer DVD_REGION too small\n"));
            status = STATUS_INVALID_PARAMETER;
            break;
        }

        //
        // figure out how much data buffer we need
        //

        keyLength = max(sizeof(DVD_DESCRIPTOR_HEADER) +
                            sizeof(DVD_COPYRIGHT_DESCRIPTOR),
                        sizeof(DVD_READ_STRUCTURE)
                        );
        keyLength = max(keyLength,
                        DVD_RPC_KEY_LENGTH
                        );

        //
        // round the size to nearest ULONGLONG -- why?
        //

        keyLength += sizeof(ULONGLONG) - (keyLength & (sizeof(ULONGLONG) - 1));

        readStructure = ExAllocatePoolWithTag(NonPagedPool,
                                              keyLength,
                                              DVD_TAG_READ_KEY);
        if (readStructure == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            break;
        }

        RtlZeroMemory (readStructure, keyLength);
        readStructure->Format = DvdCopyrightDescriptor;

        //
        // Build a request for READ_STRUCTURE
        //

        ClassSendDeviceIoControlSynchronous(
            IOCTL_DVD_READ_STRUCTURE,
            DeviceObject,
            readStructure,
            keyLength,
            sizeof(DVD_DESCRIPTOR_HEADER) +
                sizeof(DVD_COPYRIGHT_DESCRIPTOR),
            FALSE,
            &ioStatus);

        status = ioStatus.Status;

        if (!NT_SUCCESS(status)) {
            TraceLog((CdromDebugWarning,
                        "CdRomDvdGetRegion => read structure failed %x\n",
                        status));
            ExFreePool(readStructure);
            break;
        }

        //
        // we got the copyright descriptor, so now get the region if possible
        //

        dvdHeader = (PDVD_DESCRIPTOR_HEADER) readStructure;
        copyRightDescriptor = (PDVD_COPYRIGHT_DESCRIPTOR) dvdHeader->Data;

        //
        // the original irp's systembuffer has a copy of the info that
        // should be passed down in the request
        //

        dvdRegion = Irp->AssociatedIrp.SystemBuffer;

        dvdRegion->CopySystem = copyRightDescriptor->CopyrightProtectionType;
        dvdRegion->RegionData = copyRightDescriptor->RegionManagementInformation;

        //
        // now reuse the buffer to request the copy protection info
        //

        copyProtectKey = (PDVD_COPY_PROTECT_KEY) readStructure;
        RtlZeroMemory (copyProtectKey, DVD_RPC_KEY_LENGTH);
        copyProtectKey->KeyLength = DVD_RPC_KEY_LENGTH;
        copyProtectKey->KeyType = DvdGetRpcKey;

        //
        // send a request for READ_KEY
        //

        ClassSendDeviceIoControlSynchronous(
            IOCTL_DVD_READ_KEY,
            DeviceObject,
            copyProtectKey,
            DVD_RPC_KEY_LENGTH,
            DVD_RPC_KEY_LENGTH,
            FALSE,
            &ioStatus);
        status = ioStatus.Status;

        if (!NT_SUCCESS(status)) {
            TraceLog((CdromDebugWarning,
                        "CdRomDvdGetRegion => read key failed %x\n",
                        status));
            ExFreePool(readStructure);
            break;
        }

        //
        // the request succeeded.  if a supported scheme is returned,
        // then return the information to the caller
        //

        rpcKey = (PDVD_RPC_KEY) copyProtectKey->KeyData;

        if (rpcKey->RpcScheme == 1) {

            if (rpcKey->TypeCode) {

                dvdRegion->SystemRegion = ~rpcKey->RegionMask;
                dvdRegion->ResetCount = rpcKey->UserResetsAvailable;

            } else {

                //
                // the drive has not been set for any region
                //

                dvdRegion->SystemRegion = 0;
                dvdRegion->ResetCount = rpcKey->UserResetsAvailable;
            }
            Irp->IoStatus.Information = sizeof(DVD_REGION);

        } else {

            TraceLog((CdromDebugWarning,
                        "CdRomDvdGetRegion => rpcKey->RpcScheme != 1\n"));
            status = STATUS_INVALID_DEVICE_REQUEST;
        }

        ExFreePool(readStructure);
        break;
    }


    case IOCTL_STORAGE_SET_READ_AHEAD: {

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

            TraceLog((CdromDebugWarning,
                        "DvdDeviceControl: SetReadAhead buffer too small\n"));
            status = STATUS_INVALID_PARAMETER;
            break;
        }

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

        return STATUS_PENDING;
    }

    case IOCTL_DISK_IS_WRITABLE: {

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

        return STATUS_PENDING;

    }

    case IOCTL_DISK_GET_DRIVE_LAYOUT: {

        ULONG size;

        //
        // we always fake zero or one partitions, and one partition
        // structure is included in DRIVE_LAYOUT_INFORMATION
        //
        
        size = FIELD_OFFSET(DRIVE_LAYOUT_INFORMATION, PartitionEntry[1]);


        TraceLog((CdromDebugTrace,
                    "CdRomDeviceControl: Get drive layout\n"));
        if (irpStack->Parameters.DeviceIoControl.OutputBufferLength < size) {            
            status = STATUS_BUFFER_TOO_SMALL;
            Irp->IoStatus.Information = size;
            break;
        }
        
        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject, Irp, NULL, NULL);
        return STATUS_PENDING;


    }
    case IOCTL_DISK_GET_DRIVE_LAYOUT_EX: {
        
        ULONG size;

        //
        // we always fake zero or one partitions, and one partition
        // structure is included in DRIVE_LAYOUT_INFORMATION_EX
        //

        size = FIELD_OFFSET(DRIVE_LAYOUT_INFORMATION_EX, PartitionEntry[1]);

        TraceLog((CdromDebugTrace,
                    "CdRomDeviceControl: Get drive layout ex\n"));
        if (irpStack->Parameters.DeviceIoControl.OutputBufferLength < size) {            
            status = STATUS_BUFFER_TOO_SMALL;
            Irp->IoStatus.Information = size;
            break;
        }

        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject, Irp, NULL, NULL);
        return STATUS_PENDING;    
    
    }

    
    case IOCTL_DISK_GET_PARTITION_INFO: {

        //
        // Check that the buffer is large enough.
        //

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

            status = STATUS_BUFFER_TOO_SMALL;
            Irp->IoStatus.Information = sizeof(PARTITION_INFORMATION);
            break;
        }
        
        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject, Irp, NULL, NULL);
        return STATUS_PENDING;
    
    }
    case IOCTL_DISK_GET_PARTITION_INFO_EX: {

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

            status = STATUS_BUFFER_TOO_SMALL;
            Irp->IoStatus.Information = sizeof(PARTITION_INFORMATION_EX);
            break;
        }

        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject, Irp, NULL, NULL);
        return STATUS_PENDING;
    }

    case IOCTL_DISK_VERIFY: {

        TraceLog((CdromDebugTrace,
                    "IOCTL_DISK_VERIFY to device %p through irp %p\n",
                    DeviceObject, Irp));

        //
        // Validate buffer length.
        //

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

            status = STATUS_INFO_LENGTH_MISMATCH;
            break;
        }
        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject, Irp, NULL, NULL);
        return STATUS_PENDING;
    }

    case IOCTL_DISK_GET_LENGTH_INFO: {
        
        if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
            sizeof(GET_LENGTH_INFORMATION)) {
            status = STATUS_BUFFER_TOO_SMALL;
            Irp->IoStatus.Information = sizeof(GET_LENGTH_INFORMATION);
            break;
        }
        IoMarkIrpPending(Irp);
        IoStartPacket(DeviceObject, Irp, NULL, NULL);
        return STATUS_PENDING;
    }

    case IOCTL_CDROM_GET_CONFIGURATION: {

        PGET_CONFIGURATION_IOCTL_INPUT inputBuffer;

        TraceLog((CdromDebugTrace,
                    "IOCTL_CDROM_GET_CONFIGURATION to via irp %p\n", Irp));

        //
        // Validate buffer length.
        //

        if (irpStack->Parameters.DeviceIoControl.InputBufferLength !=
            sizeof(GET_CONFIGURATION_IOCTL_INPUT)) {
            status = STATUS_INFO_LENGTH_MISMATCH;
            break;
        }
        if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
            sizeof(GET_CONFIGURATION_HEADER)) {
            status = STATUS_BUFFER_TOO_SMALL;
            Irp->IoStatus.Information = sizeof(GET_CONFIGURATION_HEADER);
            break;
        }
        if (irpStack->Parameters.DeviceIoControl.OutputBufferLength > 0xffff) {
            // output buffer is too large
            status = STATUS_INVALID_BUFFER_SIZE;
            break;
        }

        //
        // also verify the arguments are reasonable.
        //

        inputBuffer = Irp->AssociatedIrp.SystemBuffer;
        if (inputBuffer->Feature > 0xffff) {
            status = STATUS_INVALID_PARAMETER;
            break;
        }
        if ((inputBuffer->RequestType != SCSI_GET_CONFIGURATION_REQUEST_TYPE_ONE) &&
            (inputBuffer->RequestType != SCSI_GET_CONFIGURATION_REQUEST_TYPE_CURRENT) &&
            (inputBuffer->RequestType != SCSI_GET_CONFIGURATION_REQUEST_TYPE_ALL)) {
            status = STATUS_INVALID_PARAMETER;
            break;
        }
        if (inputBuffer->Reserved[0] || inputBuffer->Reserved[1]) {
            status = STATUS_INVALID_PARAMETER;
            break;
        }

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

    }

    default: {

        BOOLEAN synchronize = (KeGetCurrentIrql() == PASSIVE_LEVEL);
        PKEVENT deviceControlEvent;

        //
        // If the ioctl has come in at passive level then we will synchronize
        // with our start-io routine when sending the ioctl.  If the ioctl
        // has come in at a higher interrupt level and it was not handled
        // above then it's unlikely to be a request for the class DLL - however
        // we'll still use it's common code to forward the request through.
        //

        if (synchronize) {

            deviceControlEvent = ExAllocatePoolWithTag(NonPagedPool,
                                                       sizeof(KEVENT),
                                                       CDROM_TAG_DC_EVENT);

            if (deviceControlEvent == NULL) {

                //
                // must complete this irp unsuccessful here
                //
                status = STATUS_INSUFFICIENT_RESOURCES;
                break;

            } else {

                //PIO_STACK_LOCATION currentStack;

                KeInitializeEvent(deviceControlEvent, NotificationEvent, FALSE);

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

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

                IoCopyCurrentIrpStackLocationToNext(Irp);

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

                SET_FLAG(nextStack->Flags, SL_OVERRIDE_VERIFY_VOLUME);

                IoStartPacket(DeviceObject, Irp, NULL, NULL);

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

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

                ExFreePool(deviceControlEvent);

                TraceLog((CdromDebugTrace,
                            "CdRomDeviceControl: irp %p synchronized\n", Irp));

                status = Irp->IoStatus.Status;
            }

        } else {
            status = STATUS_SUCCESS;
        }

        //
        // 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 (NT_SUCCESS(status)) {

            UCHAR uniqueAddress;

            //
            // The class device control routine will release the remove
            // lock for this Irp.  We need to make sure we have one
            // available so that it's safe to call IoStartNextPacket
            //

            if(synchronize) {

                ClassAcquireRemoveLock(DeviceObject, (PIRP)&uniqueAddress);

            }

            status = ClassDeviceControl(DeviceObject, Irp);

            if(synchronize) {
                KeRaiseIrql(DISPATCH_LEVEL, &irql);
                IoStartNextPacket(DeviceObject, FALSE);
                KeLowerIrql(irql);
                ClassReleaseRemoveLock(DeviceObject, (PIRP)&uniqueAddress);
            }
            return status;

        }

        //
        // an error occurred (either STATUS_INSUFFICIENT_RESOURCES from
        // attempting to synchronize or  StartIo() error'd this one
        // out), so we need to finish the irp, which is
        // done at the end of this routine.
        //
        break;

    } // end default case

    } // 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)) {

        if (Irp->Tail.Overlay.Thread) {
            IoSetHardErrorOrVerifyDevice(Irp, DeviceObject);
        }

    }

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

    Irp->IoStatus.Status = status;

    //
    // Complete the request.
    //

    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_DISK_INCREMENT);
    TraceLog((CdromDebugTrace,
                "CdRomDeviceControl: Status is %lx\n", status));
    return status;

} // end CdRomDeviceControl()