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