Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

1612 lines
43 KiB

/*++
Copyright (C) Microsoft Corporation, 1997 - 1999
Module Name:
changer.c
Abstract:
Authors:
Chuck Park (chuckp)
Environment:
kernel mode only
Notes:
--*/
#include "cdchgr.h"
#include "ntddcdrm.h"
#include "initguid.h"
#include "ntddstor.h"
//
// Function declarations
//
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
);
NTSTATUS
ChangerAddDevice(
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT PhysicalDeviceObject
);
NTSTATUS
ChangerPnp(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
NTSTATUS
ChangerPower(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
NTSTATUS
ChangerStartDevice(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
NTSTATUS
ChangerSendToNextDriver(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
NTSTATUS
ChangerCreate(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
NTSTATUS
ChangerPassThrough(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
NTSTATUS
ChangerDeviceControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
VOID
ChangerUnload(
IN PDRIVER_OBJECT DriverObject
);
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
Installable driver initialization entry point.
Arguments:
DriverObject - Supplies the driver object.
RegistryPath - pointer to a unicode string representing the path,
to driver-specific key in the registry.
Return Value:
STATUS_SUCCESS if successful
--*/
{
ULONG i;
DebugPrint((2,
"Changer: DriverEntry\n"));
//
// Set up the device driver entry points.
//
DriverObject->MajorFunction[IRP_MJ_CREATE] = ChangerPassThrough;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = ChangerPassThrough;
DriverObject->MajorFunction[IRP_MJ_READ] = ChangerPassThrough;
DriverObject->MajorFunction[IRP_MJ_WRITE] = ChangerPassThrough;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ChangerDeviceControl;
DriverObject->MajorFunction[IRP_MJ_PNP] = ChangerPnp;
DriverObject->MajorFunction[IRP_MJ_POWER] = ChangerPower;
DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = ChangerPassThrough;
DriverObject->DriverExtension->AddDevice = ChangerAddDevice;
DriverObject->DriverUnload = ChangerUnload;
return STATUS_SUCCESS;
} // end DriverEntry()
NTSTATUS
ChangerCreate(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine serves create commands. It does no more than
establish the drivers existence by returning status success.
Arguments:
DeviceObject
IRP
Return Value:
NT Status
--*/
{
Irp->IoStatus.Status = STATUS_SUCCESS;
IoCompleteRequest(Irp, 0);
return STATUS_SUCCESS;
}
NTSTATUS
ChangerAddDevice(
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT PhysicalDeviceObject
)
/*++
Routine Description:
Creates and initializes a new filter device object FDO for the
corresponding PDO. Then it attaches the device object to the device
stack of the drivers for the device.
Arguments:
DriverObject - Changer DriverObject.
PhysicalDeviceObject - Physical Device Object from the underlying driver
Return Value:
NTSTATUS
--*/
{
NTSTATUS status;
IO_STATUS_BLOCK ioStatus;
PDEVICE_OBJECT filterDeviceObject;
PDEVICE_EXTENSION deviceExtension;
UNICODE_STRING additionalString;
DebugPrint((2,
"ChangerAddDevice\n"));
//
// Create a filter device object for the underlying cdrom device.
//
status = IoCreateDevice(DriverObject,
DEVICE_EXTENSION_SIZE,
NULL,
FILE_DEVICE_CD_ROM,
0,
FALSE,
&filterDeviceObject);
if (!NT_SUCCESS(status)) {
DebugPrint((2,
"ChangerAddDevice: IoCreateDevice failed %lx\n",
status));
return status;
}
filterDeviceObject->Flags |= DO_DIRECT_IO;
if (filterDeviceObject->Flags & DO_POWER_INRUSH) {
DebugPrint((1,
"ChangerAddDevice: Someone set DO_POWER_INRUSH?\n",
status
));
} else {
filterDeviceObject->Flags |= DO_POWER_PAGABLE;
}
deviceExtension = (PDEVICE_EXTENSION) filterDeviceObject->DeviceExtension;
RtlZeroMemory(deviceExtension, DEVICE_EXTENSION_SIZE);
//
// Attaches the device object to the highest device object in the chain and
// return the previously highest device object, which is passed to IoCallDriver
// when pass IRPs down the device stack
//
deviceExtension->CdromTargetDeviceObject =
IoAttachDeviceToDeviceStack(filterDeviceObject, PhysicalDeviceObject);
if (deviceExtension->CdromTargetDeviceObject == NULL) {
DebugPrint((2,
"ChangerAddDevice: IoAttachDevice failed %lx\n",
STATUS_NO_SUCH_DEVICE));
IoDeleteDevice(filterDeviceObject);
return STATUS_NO_SUCH_DEVICE;
}
//
// Save the filter device object in the device extension
//
deviceExtension->DeviceObject = filterDeviceObject;
//
// Initialize the event for PagingPathNotifications
//
KeInitializeEvent(&deviceExtension->PagingPathCountEvent,
SynchronizationEvent, TRUE);
//
// Register interfaces for this device.
//
RtlInitUnicodeString(&(deviceExtension->InterfaceName), NULL);
RtlInitUnicodeString(&(additionalString), L"CdChanger");
status = IoRegisterDeviceInterface(PhysicalDeviceObject,
(LPGUID) &CdChangerClassGuid,
&additionalString,
&(deviceExtension->InterfaceName));
DebugPrint((1,
"Changer: IoRegisterDeviceInterface - status %lx",
status));
filterDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
return STATUS_SUCCESS;
} // end ChangerAddDevice()
NTSTATUS
ChgrCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PKEVENT Event
)
/*++
Routine Description:
This completion routine sets the event waited on by the start device.
Arguments:
DeviceObject - a pointer to the device object
Irp - a pointer to the irp
Event - a pointer to the event to signal
Return Value:
STATUS_MORE_PROCESSING_REQUIRED
--*/
{
KeSetEvent(Event,
IO_NO_INCREMENT,
FALSE);
return STATUS_MORE_PROCESSING_REQUIRED;
}
NTSTATUS
ChangerStartDevice(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
{
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
CCHAR dosNameBuffer[64];
CCHAR deviceNameBuffer[64];
STRING deviceNameString;
STRING dosString;
UNICODE_STRING dosUnicodeString;
UNICODE_STRING unicodeString;
PIRP irp2;
IO_STATUS_BLOCK ioStatus;
STORAGE_DEVICE_NUMBER deviceNumber;
NTSTATUS status = STATUS_INSUFFICIENT_RESOURCES;
KEVENT event;
PPASS_THROUGH_REQUEST passThrough = NULL;
PSCSI_PASS_THROUGH srb;
PCDB cdb;
//
// Get the current changer count.
//
//devicesFound = &IoGetConfigurationInformation()->MediumChangerCount;
//
// Recreate the deviceName of the underlying cdrom.
//
KeInitializeEvent(&event, NotificationEvent, FALSE);
irp2 = IoBuildDeviceIoControlRequest(IOCTL_STORAGE_GET_DEVICE_NUMBER,
deviceExtension->CdromTargetDeviceObject,
NULL,
0,
&deviceNumber,
sizeof(STORAGE_DEVICE_NUMBER),
FALSE,
&event,
&ioStatus);
if (!irp2) {
DebugPrint((1,
"ChangerStartDevice: Insufficient resources for GET_DEVICE_NUMBER request\n"));
status = STATUS_INSUFFICIENT_RESOURCES;
goto StartDeviceExit;
}
status = IoCallDriver(deviceExtension->CdromTargetDeviceObject,irp2);
if (status == STATUS_PENDING) {
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
status = ioStatus.Status;
}
if (!NT_SUCCESS(status)) {
DebugPrint((1,
"ChangerStartDevice: GetDeviceNumber failed %lx\n",
status));
goto StartDeviceExit;
}
deviceExtension->CdRomDeviceNumber = deviceNumber.DeviceNumber;
//
// Create the the arcname with the same ordinal as the underlying cdrom device.
//
sprintf(dosNameBuffer,
"\\DosDevices\\CdChanger%d",
deviceExtension->CdRomDeviceNumber);
RtlInitString(&dosString, dosNameBuffer);
status = RtlAnsiStringToUnicodeString(&dosUnicodeString,
&dosString,
TRUE);
if(!NT_SUCCESS(status)) {
status = STATUS_INSUFFICIENT_RESOURCES;
dosUnicodeString.Buffer = NULL;
}
sprintf(deviceNameBuffer,
"\\Device\\CdRom%d",
deviceExtension->CdRomDeviceNumber);
RtlInitString(&deviceNameString,
deviceNameBuffer);
status = RtlAnsiStringToUnicodeString(&unicodeString,
&deviceNameString,
TRUE);
if (!NT_SUCCESS(status)) {
status = STATUS_INSUFFICIENT_RESOURCES;
unicodeString.Buffer = NULL;
}
if (dosUnicodeString.Buffer != NULL && unicodeString.Buffer != NULL) {
//
// Link the ChangerName to the Underlying cdrom name.
//
IoCreateSymbolicLink(&dosUnicodeString, &unicodeString);
}
if (dosUnicodeString.Buffer != NULL) {
RtlFreeUnicodeString(&dosUnicodeString);
}
if (unicodeString.Buffer != NULL ) {
RtlFreeUnicodeString(&unicodeString);
}
if (NT_SUCCESS(status)) {
ULONG length;
ULONG slotCount;
//
// Get the inquiry data for the device.
// The passThrough packet will be re-used throughout.
// Ensure that the buffer is never larger than MAX_INQUIRY_DATA.
//
passThrough = ExAllocatePool(NonPagedPoolCacheAligned, sizeof(PASS_THROUGH_REQUEST) + MAX_INQUIRY_DATA);
if (!passThrough) {
DebugPrint((1,
"ChangerStartDevice: Insufficient resources for Inquiry request\n"));
status = STATUS_INSUFFICIENT_RESOURCES;
goto StartDeviceExit;
}
srb = &passThrough->Srb;
RtlZeroMemory(passThrough, sizeof(PASS_THROUGH_REQUEST) + MAX_INQUIRY_DATA);
cdb = (PCDB)srb->Cdb;
srb->TimeOutValue = 20;
srb->CdbLength = CDB6GENERIC_LENGTH;
srb->DataTransferLength = MAX_INQUIRY_DATA;
//
// Set CDB operation code.
//
cdb->CDB6INQUIRY.OperationCode = SCSIOP_INQUIRY;
//
// Set allocation length to inquiry data buffer size.
//
cdb->CDB6INQUIRY.AllocationLength = MAX_INQUIRY_DATA;
status = SendPassThrough(DeviceObject,
passThrough);
if (status == STATUS_DATA_OVERRUN) {
status = STATUS_SUCCESS;
}
if (NT_SUCCESS(status)) {
PINQUIRYDATA inquiryData;
ULONG inquiryLength;
//
// Determine the actual inquiry data length.
//
inquiryData = (PINQUIRYDATA)passThrough->DataBuffer;
inquiryLength = inquiryData->AdditionalLength + FIELD_OFFSET(INQUIRYDATA, Reserved);
if (inquiryLength > srb->DataTransferLength) {
inquiryLength = srb->DataTransferLength;
}
//
// Copy to deviceExtension buffer.
//
RtlMoveMemory(&deviceExtension->InquiryData,
inquiryData,
inquiryLength);
//
// Assume atapi 2.5, unless it's one of the special drives.
//
deviceExtension->DeviceType = ATAPI_25;
if (RtlCompareMemory(inquiryData->VendorId,"ALPS", 4) == 4) {
//
// Nominally supporting the spec. the discChanged bits are ALWAYS set
// and DiscPresent is set if the cartridge has a tray, not necessarily
// an actual disc in the tray.
//
deviceExtension->DeviceType = ALPS_25;
} else if ((RtlCompareMemory(inquiryData->VendorId, "TORiSAN CD-ROM CDR-C", 20) == 20) ||
(RtlCompareMemory(inquiryData->VendorId, "TORiSAN CD-ROM CDR_C", 20) == 20)) {
deviceExtension->DeviceType = TORISAN;
deviceExtension->NumberOfSlots = 3;
status = STATUS_SUCCESS;
}
}
if (deviceExtension->DeviceType != TORISAN) {
//
// Send an unload to ensure that the drive is empty.
// The spec. specifically states that after HW initialization
// slot0 is loaded. Good for unaware drivers, but the mech. status
// will return that slot 0 has media, and a TUR will return that
// the drive also has media.
//
RtlZeroMemory(passThrough, sizeof(PASS_THROUGH_REQUEST));
/*
cdb = (PCDB)srb->Cdb;
srb->CdbLength = CDB12GENERIC_LENGTH;
srb->TimeOutValue = CDCHGR_TIMEOUT;
srb->DataTransferLength = 0;
cdb->LOAD_UNLOAD.OperationCode = SCSIOP_LOAD_UNLOAD_SLOT;
cdb->LOAD_UNLOAD.Start = 0;
cdb->LOAD_UNLOAD.LoadEject = 1;
//
// Send SCSI command (CDB) to device
//
status = SendPassThrough(DeviceObject,
passThrough);
if (!NT_SUCCESS(status)) {
//
// Ignore this error.
//
DebugPrint((1,
"ChangerPnP - StartDevive: Unload slot0 failed. %lx\n",
status));
status = STATUS_SUCCESS;
}
*/
//
// Now send and build a mech. status request to determine the
// number of slots that the devices supports.
//
length = sizeof(MECHANICAL_STATUS_INFORMATION_HEADER);
length += (10 * sizeof(SLOT_TABLE_INFORMATION));
//
// Build srb and cdb.
//
srb = &passThrough->Srb;
RtlZeroMemory(passThrough, sizeof(PASS_THROUGH_REQUEST) + length);
cdb = (PCDB)srb->Cdb;
srb->CdbLength = CDB12GENERIC_LENGTH;
srb->DataTransferLength = length;
srb->TimeOutValue = 200;
cdb->MECH_STATUS.OperationCode = SCSIOP_MECHANISM_STATUS;
cdb->MECH_STATUS.AllocationLength[0] = (UCHAR)(length >> 8);
cdb->MECH_STATUS.AllocationLength[1] = (UCHAR)(length & 0xFF);
status = SendPassThrough(DeviceObject,
passThrough);
if (status == STATUS_DATA_OVERRUN) {
status = STATUS_SUCCESS;
}
if (NT_SUCCESS(status)) {
PMECHANICAL_STATUS_INFORMATION_HEADER statusHeader;
PSLOT_TABLE_INFORMATION slotInfo;
ULONG currentSlot;
statusHeader = (PMECHANICAL_STATUS_INFORMATION_HEADER)
passThrough->DataBuffer;
slotCount = statusHeader->NumberAvailableSlots;
DebugPrint((1,
"ChangerPnP - StartDevice: Device has %x slots\n",
slotCount));
deviceExtension->NumberOfSlots = slotCount;
}
}
if (NT_SUCCESS(status)) {
KeInitializeEvent(&event,NotificationEvent,FALSE);
//
// Issue GET_ADDRESS Ioctl to determine path, target, and lun information.
//
irp2 = IoBuildDeviceIoControlRequest(IOCTL_SCSI_GET_ADDRESS,
deviceExtension->CdromTargetDeviceObject,
NULL,
0,
&deviceExtension->ScsiAddress,
sizeof(SCSI_ADDRESS),
FALSE,
&event,
&ioStatus);
if (irp2 != NULL) {
status = IoCallDriver(deviceExtension->CdromTargetDeviceObject, irp2);
if (status == STATUS_PENDING) {
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
status = ioStatus.Status;
}
if (NT_SUCCESS(status)) {
DebugPrint((1,
"GetAddress: Port %x, Path %x, Target %x, Lun %x\n",
deviceExtension->ScsiAddress.PortNumber,
deviceExtension->ScsiAddress.PathId,
deviceExtension->ScsiAddress.TargetId,
deviceExtension->ScsiAddress.Lun));
if (deviceExtension->DeviceType != TORISAN) {
//
// Finally send a mode sense capabilities page to find out magazine size, etc.
//
length = sizeof(MODE_PARAMETER_HEADER10) + sizeof(CDVD_CAPABILITIES_PAGE);
RtlZeroMemory(passThrough, sizeof(PASS_THROUGH_REQUEST) + length);
srb = &passThrough->Srb;
cdb = (PCDB)srb->Cdb;
srb->CdbLength = CDB10GENERIC_LENGTH;
srb->DataTransferLength = length;
srb->TimeOutValue = 20;
cdb->MODE_SENSE10.OperationCode = SCSIOP_MODE_SENSE10;
cdb->MODE_SENSE10.PageCode = MODE_PAGE_CAPABILITIES;
cdb->MODE_SENSE10.AllocationLength[0] = (UCHAR)(length >> 8);
cdb->MODE_SENSE10.AllocationLength[1] = (UCHAR)(length & 0xFF);
status = SendPassThrough(DeviceObject,
passThrough);
if (status == STATUS_DATA_OVERRUN) {
status = STATUS_SUCCESS;
}
if (NT_SUCCESS(status)) {
PMODE_PARAMETER_HEADER10 modeHeader;
PCDVD_CAPABILITIES_PAGE modePage;
(ULONG_PTR)modeHeader = (ULONG_PTR)passThrough->DataBuffer;
(ULONG_PTR)modePage = (ULONG_PTR)modeHeader;
(ULONG_PTR)modePage += sizeof(MODE_PARAMETER_HEADER10);
//
// Determine whether this device uses a cartridge.
//
if ( modePage->LoadingMechanismType ==
CDVD_LMT_CHANGER_CARTRIDGE ) {
//
// Mode data indicates a cartridge.
//
deviceExtension->MechType = 1;
}
DebugPrint((1,
"ChangerStartDevice: Cartridge? %x\n",
deviceExtension->MechType));
goto StartDeviceExit;
} else {
goto StartDeviceExit;
}
} else {
//
// Torisans have a cartridge, not ind. slots.
//
deviceExtension->MechType = 1;
goto StartDeviceExit;
}
} else {
DebugPrint((1,
"ChangerStartDevice: GetAddress of Cdrom%x failed. Status %lx\n",
deviceExtension->CdRomDeviceNumber,
status));
goto StartDeviceExit;
}
} else {
status = STATUS_INSUFFICIENT_RESOURCES;
}
} else {
DebugPrint((1,
"ChangerPnP - StartDevice: Mechanism status failed %lx.\n",
status));
//
// Fall through.
//
}
}
StartDeviceExit:
if (passThrough) {
ExFreePool(passThrough);
}
if (NT_SUCCESS(status)) {
if (!deviceExtension->InterfaceStateSet) {
status = IoSetDeviceInterfaceState(&(deviceExtension->InterfaceName),
TRUE);
deviceExtension->InterfaceStateSet = TRUE;
}
Irp->IoStatus.Status = STATUS_SUCCESS;
return STATUS_SUCCESS;
} else {
Irp->IoStatus.Status = status;
return status;
}
}
NTSTATUS
ChangerPnp(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
Dispatch for PNP
Arguments:
DeviceObject - Supplies the device object.
Irp - Supplies the I/O request packet.
Return Value:
NTSTATUS
--*/
{
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
CCHAR dosNameBuffer[64];
STRING dosString;
UNICODE_STRING dosUnicodeString;
NTSTATUS status;
KEVENT event;
DebugPrint((2,
"ChangerPnP\n"));
switch (irpStack->MinorFunction) {
case IRP_MN_START_DEVICE: {
KeInitializeEvent(&event, SynchronizationEvent, FALSE);
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine( Irp,
ChgrCompletion,
&event,
TRUE,
TRUE,
TRUE);
status = IoCallDriver(deviceExtension->CdromTargetDeviceObject, Irp);
KeWaitForSingleObject(&event,
Executive,
KernelMode,
FALSE,
NULL);
if(!NT_SUCCESS(Irp->IoStatus.Status)) {
//
// Cdrom failed to start. Bail now.
//
status = Irp->IoStatus.Status;
} else {
status = ChangerStartDevice(DeviceObject,
Irp);
}
break;
}
case IRP_MN_REMOVE_DEVICE: {
//
// IoDelete fake dev. obj
//
status = IoSetDeviceInterfaceState(&(deviceExtension->InterfaceName),
FALSE);
deviceExtension->InterfaceStateSet = FALSE;
RtlFreeUnicodeString(&(deviceExtension->InterfaceName));
//
// Poison it.
//
RtlInitUnicodeString(&(deviceExtension->InterfaceName), NULL);
//
// Delete the symbolic link "CdChangerN".
//
sprintf(dosNameBuffer,
"\\DosDevices\\CdChanger%d",
deviceExtension->CdRomDeviceNumber);
RtlInitString(&dosString, dosNameBuffer);
status = RtlAnsiStringToUnicodeString(&dosUnicodeString,
&dosString,
TRUE);
ASSERT(NT_SUCCESS(status));
if (dosUnicodeString.Buffer != NULL) {
status = IoDeleteSymbolicLink(&dosUnicodeString);
RtlFreeUnicodeString(&dosUnicodeString);
}
IoDetachDevice(deviceExtension->CdromTargetDeviceObject);
return ChangerSendToNextDriver(DeviceObject, Irp);
break;
}
case IRP_MN_DEVICE_USAGE_NOTIFICATION: {
ULONG count;
BOOLEAN setPagable;
if (irpStack->Parameters.UsageNotification.Type != DeviceUsageTypePaging) {
status = ChangerSendToNextDriver(DeviceObject, Irp);
break; // out of case statement
}
//
// wait on the paging path event
//
status = KeWaitForSingleObject(&deviceExtension->PagingPathCountEvent,
Executive, KernelMode,
FALSE, NULL);
//
// if removing last paging device, need to set DO_POWER_PAGABLE
// bit here, and possible re-set it below on failure.
//
setPagable = FALSE;
if (!irpStack->Parameters.UsageNotification.InPath &&
deviceExtension->PagingPathCount == 1 ) {
//
// removing the last paging file.
// must have DO_POWER_PAGABLE bits set
//
if (DeviceObject->Flags & DO_POWER_INRUSH) {
DebugPrint((2, "ChangerPnp: last paging file removed "
"bug DO_POWER_INRUSH set, so not setting "
"DO_POWER_PAGABLE bit for DO %p\n",
DeviceObject));
} else {
DebugPrint((2, "ChangerPnp: Setting PAGABLE "
"bit for DO %p\n", DeviceObject));
DeviceObject->Flags |= DO_POWER_PAGABLE;
setPagable = TRUE;
}
}
//
// send the irp synchronously
//
KeInitializeEvent(&event, SynchronizationEvent, FALSE);
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine( Irp, ChgrCompletion,
&event, TRUE, TRUE, TRUE);
status = IoCallDriver(deviceExtension->CdromTargetDeviceObject, Irp);
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
status = Irp->IoStatus.Status;
//
// now deal with the failure and success cases.
// note that we are not allowed to fail the irp
// once it is sent to the lower drivers.
//
if (NT_SUCCESS(status)) {
IoAdjustPagingPathCount(
&deviceExtension->PagingPathCount,
irpStack->Parameters.UsageNotification.InPath);
if (irpStack->Parameters.UsageNotification.InPath) {
if (deviceExtension->PagingPathCount == 1) {
DebugPrint((2, "ChangerPnp: Clearing PAGABLE bit "
"for DO %p\n", DeviceObject));
DeviceObject->Flags &= ~DO_POWER_PAGABLE;
}
}
} else {
if (setPagable == TRUE) {
DeviceObject->Flags &= ~DO_POWER_PAGABLE;
setPagable = FALSE;
}
}
//
// set the event so the next one can occur.
//
KeSetEvent(&deviceExtension->PagingPathCountEvent,
IO_NO_INCREMENT, FALSE);
break;
}
default:
return ChangerSendToNextDriver(DeviceObject, Irp);
}
Irp->IoStatus.Status = status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return status;
} // end ChangerPnp()
NTSTATUS
ChangerSendToNextDriver(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine sends the Irp to the next driver in line
when the Irp is not processed by this driver.
Arguments:
DeviceObject
Irp
Return Value:
NTSTATUS
--*/
{
PDEVICE_EXTENSION deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
DebugPrint((2,
"ChangerSendToNextDriver\n"));
IoSkipCurrentIrpStackLocation(Irp);
return IoCallDriver(deviceExtension->CdromTargetDeviceObject, Irp);
} // end ChangerSendToNextDriver()
NTSTATUS
ChangerPower(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
{
PDEVICE_EXTENSION deviceExtension;
PoStartNextPowerIrp(Irp);
IoSkipCurrentIrpStackLocation(Irp);
deviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
return PoCallDriver(deviceExtension->CdromTargetDeviceObject, Irp);
}
NTSTATUS
ChangerDeviceControl(
PDEVICE_OBJECT DeviceObject,
PIRP Irp
)
/*++
Routine Description:
This routine handles the medium changer ioctls, and
passes down most cdrom ioctls to the target device.
Arguments:
DeviceObject
Irp
Return Value:
Status is returned.
--*/
{
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
NTSTATUS status = STATUS_SUCCESS;
DebugPrint((2,
"ChangerDeviceControl\n"));
if (ChgrIoctl(irpStack->Parameters.DeviceIoControl.IoControlCode)) {
switch (irpStack->Parameters.DeviceIoControl.IoControlCode) {
case IOCTL_CHANGER_GET_STATUS:
DebugPrint((2,
"CdChgrDeviceControl: IOCTL_CHANGER_GET_STATUS\n"));
status = ChgrGetStatus(DeviceObject, Irp);
break;
case IOCTL_CHANGER_GET_PARAMETERS:
DebugPrint((2,
"CdChgrDeviceControl: IOCTL_CHANGER_GET_PARAMETERS\n"));
//
// Validate buffer length.
//
if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
sizeof(GET_CHANGER_PARAMETERS)) {
status = STATUS_INFO_LENGTH_MISMATCH;
} else {
status = ChgrGetParameters(DeviceObject, Irp);
}
break;
case IOCTL_CHANGER_GET_PRODUCT_DATA:
DebugPrint((2,
"CdChgrDeviceControl: IOCTL_CHANGER_GET_PRODUCT_DATA\n"));
if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
sizeof(CHANGER_PRODUCT_DATA)) {
status = STATUS_INFO_LENGTH_MISMATCH;
} else {
status = ChgrGetProductData(DeviceObject, Irp);
}
break;
case IOCTL_CHANGER_SET_ACCESS:
DebugPrint((2,
"CdChgrDeviceControl: IOCTL_CHANGER_SET_ACCESS\n"));
if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
sizeof(CHANGER_SET_ACCESS)) {
status = STATUS_INFO_LENGTH_MISMATCH;
} else if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
sizeof(CHANGER_SET_ACCESS)) {
status = STATUS_INFO_LENGTH_MISMATCH;
} else {
status = ChgrSetAccess(DeviceObject, Irp);
}
break;
case IOCTL_CHANGER_GET_ELEMENT_STATUS:
DebugPrint((2,
"CdChgrDeviceControl: IOCTL_CHANGER_GET_ELEMENT_STATUS\n"));
if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
sizeof(CHANGER_READ_ELEMENT_STATUS)) {
status = STATUS_INFO_LENGTH_MISMATCH;
} else {
status = ChgrGetElementStatus(DeviceObject, Irp);
}
break;
case IOCTL_CHANGER_INITIALIZE_ELEMENT_STATUS:
DebugPrint((2,
"CdChgrDeviceControl: IOCTL_CHANGER_INITIALIZE_ELEMENT_STATUS\n"));
if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
sizeof(CHANGER_INITIALIZE_ELEMENT_STATUS)) {
status = STATUS_INFO_LENGTH_MISMATCH;
} else {
status = ChgrInitializeElementStatus(DeviceObject, Irp);
}
break;
case IOCTL_CHANGER_SET_POSITION:
DebugPrint((2,
"CdChgrDeviceControl: IOCTL_CHANGER_SET_POSITION\n"));
if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
sizeof(CHANGER_SET_POSITION)) {
status = STATUS_INFO_LENGTH_MISMATCH;
} else {
status = ChgrSetPosition(DeviceObject, Irp);
}
break;
case IOCTL_CHANGER_EXCHANGE_MEDIUM:
DebugPrint((2,
"CdChgrDeviceControl: IOCTL_CHANGER_EXCHANGE_MEDIUM\n"));
status = ChgrExchangeMedium(DeviceObject, Irp);
break;
case IOCTL_CHANGER_MOVE_MEDIUM:
DebugPrint((2,
"CdChgrDeviceControl: IOCTL_CHANGER_MOVE_MEDIUM\n"));
//if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
// sizeof(CHANGER_MOVE_MEDIUM)) {
// status = STATUS_INFO_LENGTH_MISMATCH;
//} else
if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
sizeof(CHANGER_MOVE_MEDIUM)) {
status = STATUS_INFO_LENGTH_MISMATCH;
} else {
status = ChgrMoveMedium(DeviceObject, Irp);
}
break;
case IOCTL_CHANGER_REINITIALIZE_TRANSPORT:
DebugPrint((2,
"CdChgrDeviceControl: IOCTL_CHANGER_REINITIALIZE_TRANSPORT\n"));
if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
sizeof(CHANGER_ELEMENT)) {
status = STATUS_INFO_LENGTH_MISMATCH;
} else {
status = ChgrReinitializeUnit(DeviceObject, Irp);
}
break;
case IOCTL_CHANGER_QUERY_VOLUME_TAGS:
DebugPrint((2,
"CdChgrDeviceControl: IOCTL_CHANGER_QUERY_VOLUME_TAGS\n"));
if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
sizeof(CHANGER_SEND_VOLUME_TAG_INFORMATION)) {
status = STATUS_INFO_LENGTH_MISMATCH;
} else if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
sizeof(READ_ELEMENT_ADDRESS_INFO)) {
status = STATUS_INFO_LENGTH_MISMATCH;
} else {
status = ChgrQueryVolumeTags(DeviceObject, Irp);
}
break;
default:
DebugPrint((1,
"CdChgrDeviceControl: Unhandled IOCTL\n"));
//
// Set current stack back one.
//
Irp->CurrentLocation++,
Irp->Tail.Overlay.CurrentStackLocation++;
//
// Pass unrecognized device control requests
// down to next driver layer.
//
return IoCallDriver(deviceExtension->CdromTargetDeviceObject, Irp);
}
} else {
if (deviceExtension->DeviceType == TORISAN) {
ULONG ioctlCode;
ULONG baseCode;
ULONG functionCode;
ioctlCode = irpStack->Parameters.DeviceIoControl.IoControlCode;
baseCode = ioctlCode >> 16;
functionCode = (ioctlCode & (~0xffffc003)) >> 2;
if((functionCode >= 0x200) && (functionCode <= 0x300)) {
ioctlCode = (ioctlCode & 0x0000ffff) | CTL_CODE(IOCTL_CDROM_BASE, 0, 0, 0);
}
if ((ioctlCode == IOCTL_CDROM_CHECK_VERIFY) || (ioctlCode == IOCTL_STORAGE_GET_MEDIA_TYPES_EX)) {
if (ioctlCode == IOCTL_CDROM_CHECK_VERIFY) {
//
// The fine torisan drives overload TUR as a method to switch platters. Have to send this down via passthrough with the
// appropriate bits set.
//
status = SendTorisanCheckVerify(DeviceObject, Irp);
} else if (ioctlCode == IOCTL_STORAGE_GET_MEDIA_TYPES_EX) {
PGET_MEDIA_TYPES mediaTypes = Irp->AssociatedIrp.SystemBuffer;
PDEVICE_MEDIA_INFO mediaInfo = &mediaTypes->MediaInfo[0];
DebugPrint((1,
"ChangerDeviceControl: GET_MEDIA_TYPES\n"));
//
// Yet another case of having to workaround this design. Media types requires knowing if
// media is present. As the cdrom driver will send a TUR, this will always switch to the first
// platter. So fake it here.
//
//
// Ensure that buffer is large enough.
//
if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
sizeof(GET_MEDIA_TYPES)) {
//
// Buffer too small.
//
Irp->IoStatus.Information = 0;
status = STATUS_INFO_LENGTH_MISMATCH;
} else {
//
// Set the type.
//
mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaType = CD_ROM;
mediaInfo->DeviceSpecific.RemovableDiskInfo.NumberMediaSides = 1;
mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics = MEDIA_READ_ONLY;
mediaTypes->DeviceType = FILE_DEVICE_CD_ROM;
mediaTypes->MediaInfoCount = 1;
status = SendTorisanCheckVerify(DeviceObject, Irp);
if (NT_SUCCESS(status)) {
mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics |= MEDIA_CURRENTLY_MOUNTED;
}
//todo issue IOCTL_CDROM_GET_DRIVE_GEOMETRY to fill in the geom. information.
mediaInfo->DeviceSpecific.RemovableDiskInfo.BytesPerSector = 2048;
Irp->IoStatus.Information = sizeof(GET_MEDIA_TYPES);
status = STATUS_SUCCESS;
}
}
} else {
DebugPrint((1,
"CdChgrDeviceControl: Unhandled IOCTL\n"));
//
// Set current stack back one.
//
Irp->CurrentLocation++,
Irp->Tail.Overlay.CurrentStackLocation++;
//
// Pass unrecognized device control requests
// down to next driver layer.
//
return IoCallDriver(deviceExtension->CdromTargetDeviceObject, Irp);
}
} else {
status = STATUS_SUCCESS;
if (deviceExtension->CdromTargetDeviceObject->Flags & DO_VERIFY_VOLUME) {
DebugPrint((1,
"ChangerDeviceControl: Volume needs to be verified\n"));
if (!(irpStack->Flags & SL_OVERRIDE_VERIFY_VOLUME)) {
status = STATUS_VERIFY_REQUIRED;
}
}
if (NT_SUCCESS(status)) {
//
// Set current stack back one.
//
Irp->CurrentLocation++,
Irp->Tail.Overlay.CurrentStackLocation++;
//
// Pass unrecognized device control requests
// down to next driver layer.
//
return IoCallDriver(deviceExtension->CdromTargetDeviceObject, Irp);
}
}
}
Irp->IoStatus.Status = status;
if (!NT_SUCCESS(status) && IoIsErrorUserInduced(status)) {
DebugPrint((1,
"Mcd.ChangerDeviceControl: IOCTL %x, status %lx\n",
irpStack->Parameters.DeviceIoControl.IoControlCode,
status));
IoSetHardErrorOrVerifyDevice(Irp, DeviceObject);
}
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return status;
} // end ChangerDeviceControl()
NTSTATUS
ChangerPassThrough(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
Arguments:
DeviceObject - Supplies the device object.
Irp - Supplies the IO request packet.
Return Value:
NTSTATUS
--*/
{
PDEVICE_EXTENSION deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
DebugPrint((2,
"ChangerPassThrough\n"));
IoSkipCurrentIrpStackLocation(Irp);
return IoCallDriver(deviceExtension->CdromTargetDeviceObject, Irp);
}
VOID
ChangerUnload(
IN PDRIVER_OBJECT DriverObject
)
/*++
Routine Description:
Free all the allocated resources, etc.
Arguments:
DriverObject - pointer to a driver object.
Return Value:
VOID.
--*/
{
DebugPrint((1,
"ChangerUnload\n"));
return;
}
#if DBG
ULONG ChgrDebugLevel = 0;
UCHAR DebugBuffer[128];
#endif
#if DBG
VOID
ChgrDebugPrint(
ULONG DebugPrintLevel,
PCCHAR DebugMessage,
...
)
/*++
Routine Description:
Debug print for all medium changer drivers
Arguments:
Debug print level between 0 and 3, with 3 being the most verbose.
Return Value:
None
--*/
{
va_list ap;
va_start(ap, DebugMessage);
if (DebugPrintLevel <= ChgrDebugLevel) {
vsprintf(DebugBuffer, DebugMessage, ap);
DbgPrint(DebugBuffer);
}
va_end(ap);
} // end ChgrDebugPrint()
#else
//
// DebugPrint stub
//
VOID
ChgrDebugPrint(
ULONG DebugPrintLevel,
PCCHAR DebugMessage,
...
)
{
}
#endif