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.
1101 lines
28 KiB
1101 lines
28 KiB
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 1997 - 1999
|
|
//
|
|
// File: ioctl.c
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include "cdchgr.h"
|
|
|
|
|
|
BOOLEAN
|
|
InvalidElement(
|
|
IN PDEVICE_EXTENSION DeviceExtension,
|
|
IN CHANGER_ELEMENT Element
|
|
);
|
|
|
|
|
|
|
|
BOOLEAN
|
|
ChgrIoctl(
|
|
IN ULONG Code
|
|
)
|
|
{
|
|
|
|
ULONG baseCode;
|
|
|
|
baseCode = Code >> 16;
|
|
if (baseCode == IOCTL_CHANGER_BASE) {
|
|
DebugPrint((3,
|
|
"ChngrIoctl returning TRUE for Base %x, Code %x\n",
|
|
baseCode,
|
|
Code));
|
|
|
|
return TRUE;
|
|
} else {
|
|
DebugPrint((3,
|
|
"ChngrIoctl returning FALSE for Base %x, Code %x\n",
|
|
baseCode,
|
|
Code));
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ChgrGetStatus(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
|
|
{
|
|
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
|
|
PPASS_THROUGH_REQUEST passThrough;
|
|
PSCSI_PASS_THROUGH srb;
|
|
NTSTATUS status;
|
|
ULONG length;
|
|
PCDB cdb;
|
|
|
|
//
|
|
// Allocate a request block.
|
|
//
|
|
|
|
passThrough = ExAllocatePool(NonPagedPoolCacheAligned, sizeof(PASS_THROUGH_REQUEST));
|
|
|
|
if (!passThrough) {
|
|
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
srb = &passThrough->Srb;
|
|
RtlZeroMemory(passThrough, sizeof(PASS_THROUGH_REQUEST));
|
|
cdb = (PCDB)srb->Cdb;
|
|
|
|
srb->CdbLength = CDB6GENERIC_LENGTH;
|
|
|
|
//
|
|
// Build TUR.
|
|
//
|
|
|
|
cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;
|
|
srb->TimeOutValue = 20;
|
|
|
|
srb->DataTransferLength = 0;
|
|
|
|
if (deviceExtension->DeviceType == TORISAN) {
|
|
DebugPrint((1,
|
|
"GetStatus: Using CurrentPlatter %x\n",
|
|
deviceExtension->CurrentPlatter));
|
|
srb->Cdb[7] = (UCHAR)deviceExtension->CurrentPlatter;
|
|
srb->CdbLength = 10;
|
|
}
|
|
|
|
//
|
|
// Send the request.
|
|
//
|
|
|
|
status = SendPassThrough(DeviceObject,
|
|
passThrough);
|
|
|
|
//
|
|
// Check out the status. As this is fake (taking to the cdrom drive, not to a robotic target),
|
|
// will probably have to make up some stuff.
|
|
//
|
|
|
|
if (status == STATUS_NO_MEDIA_IN_DEVICE) {
|
|
status = STATUS_SUCCESS;
|
|
}
|
|
|
|
ExFreePool(passThrough);
|
|
|
|
if (NT_SUCCESS(status)) {
|
|
|
|
if (deviceExtension->DeviceType == ATAPI_25) {
|
|
|
|
//
|
|
// Issue mech. status to see if any changed bits are set for those
|
|
// drives that actually support this.
|
|
//
|
|
|
|
length = sizeof(MECHANICAL_STATUS_INFORMATION_HEADER);
|
|
length += (deviceExtension->NumberOfSlots) * sizeof(SLOT_TABLE_INFORMATION);
|
|
|
|
passThrough = ExAllocatePool(NonPagedPoolCacheAligned, sizeof(PASS_THROUGH_REQUEST) + length);
|
|
|
|
if (!passThrough) {
|
|
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
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);
|
|
|
|
//
|
|
// Send SCSI command (CDB) to device
|
|
//
|
|
|
|
status = SendPassThrough(DeviceObject,
|
|
passThrough);
|
|
|
|
if (NT_SUCCESS(status)) {
|
|
|
|
//
|
|
// Run through slot info, looking for a set changed bit.
|
|
//
|
|
|
|
PSLOT_TABLE_INFORMATION slotInfo;
|
|
PMECHANICAL_STATUS_INFORMATION_HEADER statusHeader;
|
|
ULONG slotCount;
|
|
ULONG currentSlot;
|
|
|
|
(ULONG_PTR)statusHeader = (ULONG_PTR)passThrough->DataBuffer;
|
|
(ULONG_PTR)slotInfo = (ULONG_PTR)statusHeader;
|
|
(ULONG_PTR)slotInfo += sizeof(MECHANICAL_STATUS_INFORMATION_HEADER);
|
|
|
|
slotCount = statusHeader->SlotTableLength[1];
|
|
slotCount |= (statusHeader->SlotTableLength[0] << 8);
|
|
|
|
//
|
|
// Total slot information entries.
|
|
//
|
|
|
|
slotCount /= sizeof(SLOT_TABLE_INFORMATION);
|
|
|
|
//
|
|
// Move the slotInfo pointer to the correct entry.
|
|
//
|
|
|
|
for (currentSlot = 0; currentSlot < slotCount; currentSlot++) {
|
|
|
|
if (slotInfo->DiscChanged) {
|
|
status = STATUS_MEDIA_CHANGED;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Advance to next slot.
|
|
//
|
|
|
|
slotInfo += 1;
|
|
}
|
|
}
|
|
|
|
ExFreePool(passThrough);
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ChgrGetParameters(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
{
|
|
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
|
|
PIO_STACK_LOCATION currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
|
|
PGET_CHANGER_PARAMETERS changerParameters;
|
|
|
|
changerParameters = Irp->AssociatedIrp.SystemBuffer;
|
|
RtlZeroMemory(changerParameters, sizeof(GET_CHANGER_PARAMETERS));
|
|
|
|
changerParameters->Size = sizeof(GET_CHANGER_PARAMETERS);
|
|
|
|
changerParameters->NumberTransportElements = 1;
|
|
changerParameters->NumberStorageElements = (USHORT)deviceExtension->NumberOfSlots;
|
|
changerParameters->NumberIEElements = 0;
|
|
changerParameters->NumberDataTransferElements = 1;
|
|
changerParameters->NumberOfDoors = 0;
|
|
changerParameters->NumberCleanerSlots = 0;
|
|
|
|
changerParameters->FirstSlotNumber = 1;
|
|
changerParameters->FirstDriveNumber = 0;
|
|
changerParameters->FirstTransportNumber = 0;
|
|
changerParameters->FirstIEPortNumber = 0;
|
|
|
|
if (deviceExtension->MechType == 1) {
|
|
|
|
//
|
|
// For example, ALPS, Panasonic, Torisan.
|
|
//
|
|
|
|
changerParameters->MagazineSize = (USHORT)deviceExtension->NumberOfSlots;
|
|
|
|
changerParameters->Features0 = (CHANGER_CARTRIDGE_MAGAZINE |
|
|
CHANGER_STORAGE_SLOT |
|
|
CHANGER_LOCK_UNLOCK);
|
|
|
|
} else {
|
|
|
|
//
|
|
// For the NEC.
|
|
//
|
|
|
|
changerParameters->MagazineSize = 0;
|
|
|
|
changerParameters->Features0 = (CHANGER_STORAGE_SLOT |
|
|
CHANGER_LOCK_UNLOCK);
|
|
|
|
}
|
|
|
|
changerParameters->DriveCleanTimeout = 0;
|
|
|
|
//
|
|
// Features based on manual, nothing programatic.
|
|
//
|
|
|
|
|
|
changerParameters->MoveFromSlot = CHANGER_TO_DRIVE | CHANGER_TO_TRANSPORT;
|
|
|
|
Irp->IoStatus.Information = sizeof(GET_CHANGER_PARAMETERS);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ChgrGetProductData(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
{
|
|
|
|
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
|
|
PCHANGER_PRODUCT_DATA productData = Irp->AssociatedIrp.SystemBuffer;
|
|
|
|
RtlZeroMemory(productData, sizeof(CHANGER_PRODUCT_DATA));
|
|
|
|
//
|
|
// Copy cached inquiry data fields into the system buffer.
|
|
//
|
|
|
|
RtlMoveMemory(productData->VendorId, deviceExtension->InquiryData.VendorId, VENDOR_ID_LENGTH);
|
|
RtlMoveMemory(productData->ProductId, deviceExtension->InquiryData.ProductId, PRODUCT_ID_LENGTH);
|
|
RtlMoveMemory(productData->Revision, deviceExtension->InquiryData.ProductRevisionLevel, REVISION_LENGTH);
|
|
|
|
productData->DeviceType = MEDIUM_CHANGER;
|
|
|
|
Irp->IoStatus.Information = sizeof(CHANGER_PRODUCT_DATA);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ChgrSetAccess(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
{
|
|
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
|
|
PCHANGER_SET_ACCESS setAccess = Irp->AssociatedIrp.SystemBuffer;
|
|
ULONG controlOperation = setAccess->Control;
|
|
PPASS_THROUGH_REQUEST passThrough;
|
|
PSCSI_PASS_THROUGH srb;
|
|
NTSTATUS status;
|
|
PCDB cdb;
|
|
|
|
|
|
if (setAccess->Element.ElementType != ChangerDoor) {
|
|
|
|
//
|
|
// No IEPORTs on these devices.
|
|
//
|
|
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
//
|
|
// Allocate a request block.
|
|
//
|
|
|
|
passThrough = ExAllocatePool(NonPagedPoolCacheAligned, sizeof(PASS_THROUGH_REQUEST));
|
|
|
|
if (!passThrough) {
|
|
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
srb = &passThrough->Srb;
|
|
RtlZeroMemory(passThrough, sizeof(PASS_THROUGH_REQUEST));
|
|
cdb = (PCDB)srb->Cdb;
|
|
|
|
srb->CdbLength = CDB6GENERIC_LENGTH;
|
|
cdb->MEDIA_REMOVAL.OperationCode = SCSIOP_MEDIUM_REMOVAL;
|
|
|
|
srb->DataTransferLength = 0;
|
|
srb->TimeOutValue = 10;
|
|
|
|
status = STATUS_SUCCESS;
|
|
|
|
if (controlOperation == LOCK_ELEMENT) {
|
|
|
|
//
|
|
// Issue prevent media removal command to lock the magazine.
|
|
//
|
|
|
|
cdb->MEDIA_REMOVAL.Prevent = 1;
|
|
|
|
} else if (controlOperation == UNLOCK_ELEMENT) {
|
|
|
|
//
|
|
// Issue allow media removal.
|
|
//
|
|
|
|
cdb->MEDIA_REMOVAL.Prevent = 0;
|
|
|
|
} else {
|
|
|
|
status = STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (NT_SUCCESS(status)) {
|
|
|
|
//
|
|
// Send the request.
|
|
//
|
|
|
|
status = SendPassThrough(DeviceObject,
|
|
passThrough);
|
|
}
|
|
|
|
ExFreePool(passThrough);
|
|
if (NT_SUCCESS(status)) {
|
|
Irp->IoStatus.Information = sizeof(CHANGER_SET_ACCESS);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ChgrGetElementStatus(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
{
|
|
|
|
return STATUS_INVALID_DEVICE_REQUEST;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ChgrInitializeElementStatus(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
{
|
|
|
|
return STATUS_INVALID_DEVICE_REQUEST;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ChgrSetPosition(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
{
|
|
//
|
|
// These device don't support this.
|
|
//
|
|
|
|
return STATUS_INVALID_DEVICE_REQUEST;
|
|
|
|
}
|
|
|
|
NTSTATUS
|
|
ChgrExchangeMedium(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
|
|
{
|
|
//
|
|
// These device don't support this.
|
|
//
|
|
|
|
return STATUS_INVALID_DEVICE_REQUEST;
|
|
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ChgrReinitializeUnit(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
|
|
{
|
|
//
|
|
// These device don't support this.
|
|
//
|
|
|
|
return STATUS_INVALID_DEVICE_REQUEST;
|
|
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ChgrQueryVolumeTags(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
|
|
{
|
|
//
|
|
// These device don't support this.
|
|
//
|
|
|
|
return STATUS_INVALID_DEVICE_REQUEST;
|
|
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ChgrMoveMedium(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
{
|
|
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
|
|
PCHANGER_MOVE_MEDIUM moveMedium = Irp->AssociatedIrp.SystemBuffer;
|
|
USHORT transport;
|
|
USHORT source;
|
|
USHORT destination;
|
|
PPASS_THROUGH_REQUEST passThrough;
|
|
PSCSI_PASS_THROUGH srb;
|
|
PCDB cdb;
|
|
NTSTATUS status;
|
|
|
|
//
|
|
// Verify transport, source, and dest. are within range.
|
|
//
|
|
|
|
if (InvalidElement(deviceExtension,moveMedium->Transport)) {
|
|
DebugPrint((1,
|
|
"ChangerMoveMedium: Transport element out of range.\n"));
|
|
|
|
return STATUS_ILLEGAL_ELEMENT_ADDRESS;
|
|
}
|
|
|
|
if (InvalidElement(deviceExtension, moveMedium->Source)) {
|
|
|
|
DebugPrint((1,
|
|
"ChangerMoveMedium: Source element out of range.\n"));
|
|
|
|
return STATUS_ILLEGAL_ELEMENT_ADDRESS;
|
|
|
|
}
|
|
|
|
if (InvalidElement(deviceExtension,moveMedium->Destination)) {
|
|
|
|
DebugPrint((1,
|
|
"ChangerMoveMedium: Destination element out of range.\n"));
|
|
|
|
return STATUS_ILLEGAL_ELEMENT_ADDRESS;
|
|
}
|
|
|
|
//
|
|
// Build srb and cdb.
|
|
//
|
|
|
|
passThrough = ExAllocatePool(NonPagedPoolCacheAligned, sizeof(PASS_THROUGH_REQUEST));
|
|
|
|
if (!passThrough) {
|
|
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
//
|
|
// The torisan units don't really move medium, rather the active disc is changed.
|
|
// To change slots, they've overloaded TUR.
|
|
//
|
|
|
|
if (deviceExtension->DeviceType == TORISAN) {
|
|
|
|
if (moveMedium->Destination.ElementType == ChangerDrive) {
|
|
|
|
srb = &passThrough->Srb;
|
|
RtlZeroMemory(passThrough, sizeof(PASS_THROUGH_REQUEST));
|
|
cdb = (PCDB)srb->Cdb;
|
|
|
|
srb->CdbLength = CDB10GENERIC_LENGTH;
|
|
|
|
//
|
|
// Build TUR.
|
|
//
|
|
|
|
cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;
|
|
|
|
srb->Cdb[7] = (UCHAR)moveMedium->Source.ElementAddress;
|
|
srb->TimeOutValue = 20;
|
|
|
|
srb->DataTransferLength = 0;
|
|
|
|
//
|
|
// Send the request.
|
|
//
|
|
|
|
status = SendPassThrough(DeviceObject,
|
|
passThrough);
|
|
|
|
if (status == STATUS_DEVICE_NOT_READY) {
|
|
|
|
// TODO send a TUR to verify this.
|
|
|
|
DebugPrint((1,
|
|
"MoveMedium - Claiming success\n"));
|
|
status = STATUS_SUCCESS;
|
|
} else if (status == STATUS_NO_MEDIA_IN_DEVICE) {
|
|
status = STATUS_SOURCE_ELEMENT_EMPTY;
|
|
}
|
|
|
|
if (NT_SUCCESS(status)) {
|
|
|
|
//
|
|
// Update the current disc indicator.
|
|
//
|
|
|
|
deviceExtension->CurrentPlatter = moveMedium->Source.ElementAddress;
|
|
DebugPrint((1,
|
|
"MoveMedium: Set currentPlatter to %x\n",
|
|
deviceExtension->CurrentPlatter));
|
|
|
|
ExFreePool(passThrough);
|
|
return STATUS_SUCCESS;
|
|
|
|
} else {
|
|
DebugPrint((1,
|
|
"MoveMedium - Status on move %lx\n",
|
|
status));
|
|
|
|
ExFreePool(passThrough);
|
|
return status;
|
|
}
|
|
|
|
|
|
} else {
|
|
|
|
//
|
|
// Claim that is happened.
|
|
//
|
|
|
|
|
|
ExFreePool(passThrough);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If destination is the drive, determine if media is already present.
|
|
// The alps always claims media is there, so don't check.
|
|
//
|
|
|
|
#if 0
|
|
if (((moveMedium->Destination.ElementType) == ChangerDrive) &&
|
|
(deviceExtension->DeviceType != ALPS_25)) {
|
|
|
|
srb = &passThrough->Srb;
|
|
RtlZeroMemory(passThrough, sizeof(PASS_THROUGH_REQUEST));
|
|
cdb = (PCDB)srb->Cdb;
|
|
|
|
srb->CdbLength = CDB6GENERIC_LENGTH;
|
|
|
|
//
|
|
// Build TUR.
|
|
//
|
|
|
|
cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;
|
|
srb->TimeOutValue = 20;
|
|
|
|
srb->DataTransferLength = 0;
|
|
|
|
//
|
|
// Send the request.
|
|
//
|
|
|
|
status = SendPassThrough(DeviceObject,
|
|
passThrough);
|
|
|
|
if (status != STATUS_NO_MEDIA_IN_DEVICE) {
|
|
|
|
//
|
|
// Drive has media. Though the device will allow this,
|
|
// error it, as the expected medium changer behaviour is
|
|
// to return element full in this case.
|
|
//
|
|
|
|
DebugPrint((1,
|
|
"ChgrMoveMedium: Drive already has media. TUR Status %lx\n",
|
|
status));
|
|
|
|
ExFreePool(passThrough);
|
|
return STATUS_DESTINATION_ELEMENT_FULL;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
srb = &passThrough->Srb;
|
|
RtlZeroMemory(passThrough, sizeof(PASS_THROUGH_REQUEST));
|
|
cdb = (PCDB)srb->Cdb;
|
|
|
|
srb->CdbLength = CDB12GENERIC_LENGTH;
|
|
srb->TimeOutValue = CDCHGR_TIMEOUT;
|
|
srb->DataTransferLength = 0;
|
|
|
|
//
|
|
// LOAD_UNLOAD will move a disc from slot to drive,
|
|
// or from drive to slot.
|
|
//
|
|
|
|
cdb->LOAD_UNLOAD.OperationCode = SCSIOP_LOAD_UNLOAD_SLOT;
|
|
if (moveMedium->Source.ElementType == ChangerDrive) {
|
|
|
|
cdb->LOAD_UNLOAD.Slot = (UCHAR)moveMedium->Destination.ElementAddress;
|
|
cdb->LOAD_UNLOAD.Start = 0;
|
|
cdb->LOAD_UNLOAD.LoadEject = 1;
|
|
|
|
|
|
} else if (moveMedium->Source.ElementType == ChangerSlot) {
|
|
|
|
cdb->LOAD_UNLOAD.Slot = (UCHAR)moveMedium->Source.ElementAddress;
|
|
cdb->LOAD_UNLOAD.Start = 1;
|
|
cdb->LOAD_UNLOAD.LoadEject = 1;
|
|
}
|
|
|
|
//
|
|
// Send SCSI command (CDB) to device
|
|
//
|
|
|
|
status = SendPassThrough(DeviceObject,
|
|
passThrough);
|
|
|
|
if (NT_SUCCESS(status)) {
|
|
|
|
//
|
|
// These devices don't seem to ever generate
|
|
// a unit attention, for media changed, so fake it.
|
|
//
|
|
|
|
if (deviceExtension->CdromTargetDeviceObject->Vpb->Flags & VPB_MOUNTED) {
|
|
|
|
DebugPrint((1,
|
|
"Faking DO_VERIFY_VOLUME\n"));
|
|
|
|
deviceExtension->CdromTargetDeviceObject->Flags |= DO_VERIFY_VOLUME;
|
|
}
|
|
|
|
} else if (status == STATUS_NO_MEDIA_IN_DEVICE) {
|
|
status = STATUS_SOURCE_ELEMENT_EMPTY;
|
|
}
|
|
|
|
ExFreePool(passThrough);
|
|
return status;
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
InvalidElement(
|
|
IN PDEVICE_EXTENSION DeviceExtension,
|
|
IN CHANGER_ELEMENT Element
|
|
)
|
|
{
|
|
if (Element.ElementType == ChangerSlot) {
|
|
if (Element.ElementAddress >= DeviceExtension->NumberOfSlots) {
|
|
DebugPrint((1,
|
|
"Cdchgr: InvalidElement - type %x, address %x\n",
|
|
Element.ElementType,
|
|
Element.ElementAddress));
|
|
return TRUE;
|
|
}
|
|
} else if (Element.ElementType == ChangerDrive) {
|
|
if (Element.ElementAddress != 0) {
|
|
DebugPrint((1,
|
|
"Cdchgr: InvalidElement - type %x, address %x\n",
|
|
Element.ElementType,
|
|
Element.ElementAddress));
|
|
return TRUE;
|
|
}
|
|
} else if (Element.ElementType == ChangerTransport) {
|
|
if (Element.ElementAddress != 0) {
|
|
DebugPrint((1,
|
|
"Cdchgr: InvalidElement - type %x, address %x\n",
|
|
Element.ElementType,
|
|
Element.ElementAddress));
|
|
return TRUE;
|
|
}
|
|
} else {
|
|
|
|
DebugPrint((1,
|
|
"Cdchgr: InvalidElement - type %x, address %x\n",
|
|
Element.ElementType,
|
|
Element.ElementAddress));
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Acceptable element/address.
|
|
//
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
MapSenseInfo(
|
|
IN PSENSE_DATA SenseBuffer
|
|
)
|
|
|
|
{
|
|
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
UCHAR senseCode = SenseBuffer->SenseKey;
|
|
UCHAR additionalSenseCode = SenseBuffer->AdditionalSenseCode;
|
|
UCHAR additionalSenseCodeQualifier = SenseBuffer->AdditionalSenseCodeQualifier;
|
|
|
|
switch (senseCode) {
|
|
case SCSI_SENSE_NO_SENSE:
|
|
|
|
if (SenseBuffer->IncorrectLength) {
|
|
|
|
status = STATUS_INVALID_BLOCK_LENGTH;
|
|
|
|
} else {
|
|
|
|
status = STATUS_IO_DEVICE_ERROR;
|
|
}
|
|
|
|
break;
|
|
|
|
case SCSI_SENSE_RECOVERED_ERROR:
|
|
|
|
status = STATUS_SUCCESS;
|
|
break;
|
|
|
|
case SCSI_SENSE_NOT_READY:
|
|
|
|
status = STATUS_DEVICE_NOT_READY;
|
|
|
|
switch (additionalSenseCode) {
|
|
case SCSI_ADSENSE_LUN_NOT_READY:
|
|
|
|
switch (additionalSenseCodeQualifier) {
|
|
|
|
case SCSI_SENSEQ_MANUAL_INTERVENTION_REQUIRED:
|
|
|
|
status = STATUS_NO_MEDIA_IN_DEVICE;
|
|
break;
|
|
case SCSI_SENSEQ_INIT_COMMAND_REQUIRED:
|
|
case SCSI_SENSEQ_BECOMING_READY:
|
|
|
|
//
|
|
// Fall through.
|
|
//
|
|
default:
|
|
|
|
status = STATUS_DEVICE_NOT_READY;
|
|
|
|
}
|
|
break;
|
|
|
|
case SCSI_ADSENSE_NO_MEDIA_IN_DEVICE:
|
|
|
|
status = STATUS_NO_MEDIA_IN_DEVICE;
|
|
break;
|
|
default:
|
|
status = STATUS_DEVICE_NOT_READY;
|
|
|
|
}
|
|
break;
|
|
|
|
case SCSI_SENSE_MEDIUM_ERROR:
|
|
|
|
status = STATUS_DEVICE_DATA_ERROR;
|
|
break;
|
|
|
|
case SCSI_SENSE_ILLEGAL_REQUEST:
|
|
|
|
switch (additionalSenseCode) {
|
|
|
|
case SCSI_ADSENSE_ILLEGAL_BLOCK:
|
|
status = STATUS_NONEXISTENT_SECTOR;
|
|
break;
|
|
|
|
case SCSI_ADSENSE_INVALID_LUN:
|
|
status = STATUS_NO_SUCH_DEVICE;
|
|
break;
|
|
|
|
case SCSI_ADSENSE_MUSIC_AREA:
|
|
case SCSI_ADSENSE_DATA_AREA:
|
|
case SCSI_ADSENSE_VOLUME_OVERFLOW:
|
|
case SCSI_ADSENSE_ILLEGAL_COMMAND:
|
|
case SCSI_ADSENSE_INVALID_CDB:
|
|
default:
|
|
|
|
status = STATUS_INVALID_DEVICE_REQUEST;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case SCSI_SENSE_UNIT_ATTENTION:
|
|
|
|
// TODO - check on this.
|
|
DebugPrint((1,
|
|
"MapSenseInfo: UnitAttention \n"));
|
|
|
|
status = STATUS_VERIFY_REQUIRED;
|
|
break;
|
|
|
|
case SCSI_SENSE_DATA_PROTECT:
|
|
|
|
status = STATUS_MEDIA_WRITE_PROTECTED;
|
|
break;
|
|
|
|
case SCSI_SENSE_HARDWARE_ERROR:
|
|
case SCSI_SENSE_ABORTED_COMMAND:
|
|
|
|
//
|
|
// Fall through.
|
|
//
|
|
|
|
default:
|
|
|
|
status = STATUS_IO_DEVICE_ERROR;
|
|
break;
|
|
}
|
|
|
|
DebugPrint((1,
|
|
"CdChgr: MapSenseInfo - SK %x, ASC %x, ASCQ %x, Status %lx\n",
|
|
senseCode,
|
|
additionalSenseCode,
|
|
additionalSenseCodeQualifier,
|
|
status));
|
|
return status;
|
|
}
|
|
|
|
|
|
|
|
NTSTATUS
|
|
SendTorisanCheckVerify(
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine handles only the check verify commands for the Sanyo changers.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject
|
|
Irp
|
|
|
|
Return Value:
|
|
|
|
Status is returned.
|
|
|
|
--*/
|
|
|
|
{
|
|
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
|
|
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
|
|
PPASS_THROUGH_REQUEST passThrough;
|
|
PSCSI_PASS_THROUGH srb;
|
|
NTSTATUS status;
|
|
ULONG length;
|
|
PCDB cdb;
|
|
|
|
//
|
|
// Allocate a request block.
|
|
//
|
|
|
|
passThrough = ExAllocatePool(NonPagedPoolCacheAligned, sizeof(PASS_THROUGH_REQUEST));
|
|
|
|
if (!passThrough) {
|
|
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
srb = &passThrough->Srb;
|
|
RtlZeroMemory(passThrough, sizeof(PASS_THROUGH_REQUEST));
|
|
cdb = (PCDB)srb->Cdb;
|
|
|
|
srb->CdbLength = CDB10GENERIC_LENGTH;
|
|
|
|
//
|
|
// Build TUR.
|
|
//
|
|
|
|
cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;
|
|
srb->TimeOutValue = 20;
|
|
|
|
DebugPrint((1,
|
|
"SendTorisanCheckVerify: Using CurrentPlatter of %x\n",
|
|
deviceExtension->CurrentPlatter));
|
|
|
|
srb->Cdb[7] = (UCHAR)deviceExtension->CurrentPlatter;
|
|
srb->DataTransferLength = 0;
|
|
|
|
//
|
|
// Send the request.
|
|
//
|
|
|
|
status = SendPassThrough(DeviceObject,
|
|
passThrough);
|
|
|
|
|
|
ExFreePool(passThrough);
|
|
return status;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
SendPassThrough(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PPASS_THROUGH_REQUEST ScsiPassThrough
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine fills in most SPT fields, then sends the given SRB synchronously
|
|
to the CDROM class driver.
|
|
DataTransferLength, TimeoutValue are the responsibility of the caller.
|
|
|
|
Arguments:
|
|
|
|
Extension - Supplies the device extension.
|
|
|
|
Srb - Supplies the SRB.
|
|
|
|
Buffer - Supplies the return buffer.
|
|
|
|
BufferLength - Supplies the buffer length.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS
|
|
|
|
--*/
|
|
|
|
|
|
//typedef struct _PASS_THROUGH_REQUEST {
|
|
// SCSI_PASS_THROUGH Srb;
|
|
// SENSE_DATA SenseInfoBuffer;
|
|
// CHAR DataBuffer[0];
|
|
//} PASS_THROUGH_REQUEST, *PPASS_THROUGH_REQUEST;
|
|
|
|
|
|
//typedef struct _SCSI_PASS_THROUGH {
|
|
// USHORT Length;
|
|
// UCHAR ScsiStatus;
|
|
// UCHAR PathId;
|
|
// UCHAR TargetId;
|
|
// UCHAR Lun;
|
|
// UCHAR CdbLength;
|
|
// UCHAR SenseInfoLength;
|
|
// UCHAR DataIn;
|
|
// ULONG DataTransferLength;
|
|
// ULONG TimeOutValue;
|
|
// ULONG DataBufferOffset;
|
|
// ULONG SenseInfoOffset;
|
|
// UCHAR Cdb[16];
|
|
//}SCSI_PASS_THROUGH, *PSCSI_PASS_THROUGH;
|
|
|
|
{
|
|
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
|
|
PSCSI_PASS_THROUGH srb = &ScsiPassThrough->Srb;
|
|
KEVENT event;
|
|
PIRP irp;
|
|
IO_STATUS_BLOCK ioStatus;
|
|
NTSTATUS status;
|
|
|
|
srb->Length = sizeof(SCSI_PASS_THROUGH);
|
|
srb->SenseInfoLength = sizeof(SENSE_DATA);
|
|
srb->SenseInfoOffset = FIELD_OFFSET(PASS_THROUGH_REQUEST, SenseInfoBuffer);
|
|
|
|
if (srb->DataTransferLength) {
|
|
|
|
srb->DataBufferOffset = FIELD_OFFSET(PASS_THROUGH_REQUEST, DataBuffer);
|
|
srb->DataIn = SCSI_IOCTL_DATA_IN;
|
|
} else {
|
|
|
|
srb->DataIn = SCSI_IOCTL_DATA_OUT;
|
|
srb->DataBufferOffset = 0;
|
|
}
|
|
|
|
KeInitializeEvent(&event,
|
|
NotificationEvent,
|
|
FALSE);
|
|
|
|
irp = IoBuildDeviceIoControlRequest(IOCTL_SCSI_PASS_THROUGH,
|
|
deviceExtension->CdromTargetDeviceObject,
|
|
ScsiPassThrough,
|
|
sizeof(PASS_THROUGH_REQUEST) + srb->DataTransferLength,
|
|
ScsiPassThrough,
|
|
sizeof(PASS_THROUGH_REQUEST) + srb->DataTransferLength,
|
|
FALSE,
|
|
&event,
|
|
&ioStatus);
|
|
if (!irp) {
|
|
DebugPrint((1,
|
|
"Cdchgr: SendPassThrough NULL irp\n"));
|
|
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
status = IoCallDriver(deviceExtension->CdromTargetDeviceObject,
|
|
irp);
|
|
|
|
if (status == STATUS_PENDING) {
|
|
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
|
|
status = ioStatus.Status;
|
|
}
|
|
|
|
//
|
|
// Check status and map appropriately.
|
|
//
|
|
|
|
if (srb->ScsiStatus != SCSISTAT_GOOD) {
|
|
|
|
if (srb->ScsiStatus == SCSISTAT_CHECK_CONDITION) {
|
|
|
|
status = MapSenseInfo(&ScsiPassThrough->SenseInfoBuffer);
|
|
if (status == STATUS_VERIFY_REQUIRED) {
|
|
|
|
if (DeviceObject->Vpb->Flags & VPB_MOUNTED) {
|
|
|
|
DeviceObject->Flags |= DO_VERIFY_VOLUME;
|
|
}
|
|
}
|
|
} else {
|
|
|
|
DebugPrint((1,
|
|
"Cdchgr: Unhandled scsi status %lx\n",
|
|
srb->ScsiStatus));
|
|
status = STATUS_IO_DEVICE_ERROR;
|
|
|
|
}
|
|
}
|
|
|
|
DebugPrint((1,
|
|
"Cdchgr: SendSrbPassThrough Status %lx\n",
|
|
status));
|
|
|
|
return status;
|
|
}
|